原文：http://zetcode.com/java/jfreechart/

在本教程中，我们学习如何使用 JFreeChart。 我们展示了如何创建各种类型的图表。 图表显示在 Swing 应用中，并保存到图像文件中。 我们使用 Java Servlet 在 Web 浏览器中创建和呈现图表，并从 MySQL 数据库检索图表数据。

JFreeChart 库

图表是一种以简单方式显示信息的图形，通常使用直线和曲线来显示金额。 JFreeChart 是用于创建图表的流行 Java 库。 JFreeChart 允许创建各种交互式和非交互式图表。 我们可以创建折线图，条形图，面积图，散点图，饼图，甘特图和各种专用图，例如风向图或气泡图。

JFreeChart 可以广泛地定制； 它允许修改图表项目的颜色和绘制，图例，线条或标记的样式。 它会自动绘制轴刻度和图例。 图表具有内置功能，可使用鼠标放大。 现有的图表可以通过库在其数据集合上具有的监听器轻松更新。 它支持多种输出格式，包括 PNG，JPEG，PDF 和 SVG。

JFreeChart 由 David Gilbert 于 2000 年创立。如今，JFreeChart 是 Java 开发者中使用最广泛的图表库。

JFreeChart Maven 依赖项

  1. <dependency>
  2.     <groupId>org.jfree</groupId>
  3.     <artifactId>jfreechart</artifactId>
  4.     <version>1.0.19</version>
  5. </dependency>

对于我们的项目，我们使用此 Maven 依赖项。

JFreeChart 折线图

折线图是一种基本类型的图表，它将信息显示为由直线段连接的一系列数据点。 JavaFX 中的折线图是使用ChartFactory.createXYLineChart()创建的。

LineChartEx.java

  1. package com.zetcode.linechartex;
  3. import java.awt.BasicStroke;
  4. import java.awt.Color;
  5. import java.awt.Font;
  6. import javax.swing.BorderFactory;
  7. import javax.swing.JFrame;
  8. import javax.swing.SwingUtilities;
  9. import org.jfree.chart.ChartFactory;
  10. import org.jfree.chart.ChartPanel;
  11. import org.jfree.chart.JFreeChart;
  12. import org.jfree.chart.axis.NumberAxis;
  13. import org.jfree.chart.block.BlockBorder;
  14. import org.jfree.chart.plot.PlotOrientation;
  15. import org.jfree.chart.plot.XYPlot;
  16. import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
  17. import org.jfree.chart.title.TextTitle;
  18. import org.jfree.data.xy.XYDataset;
  19. import org.jfree.data.xy.XYSeries;
  20. import org.jfree.data.xy.XYSeriesCollection;
  22. public class LineChartEx extends JFrame {
  24.     public LineChartEx() {
  26.         initUI();
  27.     }
  29.     private void initUI() {
  31.         XYDataset dataset = createDataset();
  32.         JFreeChart chart = createChart(dataset);
  33.         ChartPanel chartPanel = new ChartPanel(chart);
  34.         chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
  35.         chartPanel.setBackground(Color.white);
  36.         add(chartPanel);
  38.         pack();
  39.         setTitle("Line chart");
  40.         setLocationRelativeTo(null);
  41.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  42.     }
  44.     private XYDataset createDataset() {
  46.         XYSeries series = new XYSeries("2016");
  47.         series.add(18, 567);
  48.         series.add(20, 612);
  49.         series.add(25, 800);
  50.         series.add(30, 980);
  51.         series.add(40, 1410);
  52.         series.add(50, 2350);
  54.         XYSeriesCollection dataset = new XYSeriesCollection();
  55.         dataset.addSeries(series);
  57.         return dataset;
  58.     }
  60.     private JFreeChart createChart(XYDataset dataset) {
  62.         JFreeChart chart = ChartFactory.createXYLineChart(
  63.                 "Average salary per age", 
  64.                 "Age", 
  65.                 "Salary (€)", 
  66.                 dataset, 
  67.                 PlotOrientation.VERTICAL,
  68.                 true, 
  69.                 true, 
  70.                 false 
  71.         );
  73.         XYPlot plot = chart.getXYPlot();
  75.         XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
  76.         renderer.setSeriesPaint(0, Color.RED);
  77.         renderer.setSeriesStroke(0, new BasicStroke(2.0f));
  79.         plot.setRenderer(renderer);
  80.         plot.setBackgroundPaint(Color.white);
  82.         plot.setRangeGridlinesVisible(true);
  83.         plot.setRangeGridlinePaint(Color.BLACK);
  85.         plot.setDomainGridlinesVisible(true);
  86.         plot.setDomainGridlinePaint(Color.BLACK);
  88.         chart.getLegend().setFrame(BlockBorder.NONE);
  90.         chart.setTitle(new TextTitle("Average Salary per Age",
  91.                         new Font("Serif", java.awt.Font.BOLD, 18)
  92.                 )
  93.         );
  95.         return chart;
  97.     }
  99.     public static void main(String[] args) {
  101.         SwingUtilities.invokeLater(() -> {
  102.             LineChartEx ex = new LineChartEx();
  103.             ex.setVisible(true);
  104.         });
  105.     }
  106. }

在示例中，我们创建了一个折线图，显示每个年龄段的平均工资。

  1. XYSeries series = new XYSeries("2016");
  2. series.add(18, 567);
  3. series.add(20, 612);
  4. series.add(25, 800);
  5. ...

XYSeries表示形式为(x, y)的零个或多个数据项的序列。

  1. XYSeriesCollection dataset = new XYSeriesCollection();
  2. dataset.addSeries(series);

该系列将添加到XYSeriesCollection中，该XYSeriesCollection是可以用作数据集的XYSeries对象的集合。

  1. JFreeChart chart = ChartFactory.createXYLineChart(
  2.         "Average salary per age", 
  3.         "Age", 
  4.         "Salary (€)", 
  5.         dataset, 
  6.         PlotOrientation.VERTICAL,
  7.         true, 
  8.         true, 
  9.         false 
  10. );

ChartFactory.createXYLineChart()创建一个新的折线图。 该方法的参数是：图表标题，X 轴标签，Y 轴标签，数据，绘图方向和三个标志，指示是否显示图例，工具提示和 URL。

  1. XYPlot plot = chart.getXYPlot();

我们可以参考该图以对其进行自定义。

  1. XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
  2. renderer.setSeriesPaint(0, Color.RED);
  3. renderer.setSeriesStroke(0, new BasicStroke(2.0f));
  4. plot.setRenderer(renderer);

在这里，我们为图表线设置了描边和颜色。 XYLineAndShapeRenderer是将数据点与线连接和/或在每个数据点绘制形状的对象。 渲染器通过setRenderer()方法设置。

  1. plot.setBackgroundPaint(Color.white);

setBackgroundPaint()设置绘图区域的背景颜色。

  1. plot.setRangeGridlinesVisible(true);
  2. plot.setRangeGridlinePaint(Color.BLACK);
  4. plot.setDomainGridlinesVisible(true);
  5. plot.setDomainGridlinePaint(Color.BLACK);

我们显示网格线并将其涂成黑色。

  1. chart.getLegend().setFrame(BlockBorder.NONE);

我们删除图例周围的边框。

  1. chart.setTitle(new TextTitle("Average Salary per Age",
  2.                 new Font("Serif", java.awt.Font.BOLD, 18)
  3.         )
  4. );

我们使用新字体创建图表标题。

JFreeChart 教程 - 图1

图：折线图

带有两个序列的折线图

在第二个示例中，我们创建具有两个数据序列的折线图。

LineChartEx2.java

  1. package com.zetcode.linechartex2;
  3. import java.awt.BasicStroke;
  4. import java.awt.Color;
  5. import java.awt.Font;
  6. import javax.swing.BorderFactory;
  7. import javax.swing.JFrame;
  8. import javax.swing.SwingUtilities;
  9. import org.jfree.chart.ChartFactory;
  10. import org.jfree.chart.ChartPanel;
  11. import org.jfree.chart.JFreeChart;
  12. import org.jfree.chart.block.BlockBorder;
  13. import org.jfree.chart.plot.PlotOrientation;
  14. import org.jfree.chart.plot.XYPlot;
  15. import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
  16. import org.jfree.chart.title.TextTitle;
  17. import org.jfree.data.xy.XYDataset;
  18. import org.jfree.data.xy.XYSeries;
  19. import org.jfree.data.xy.XYSeriesCollection;
  21. public class LineChartEx2 extends JFrame {
  23.     public LineChartEx2() {
  25.         initUI();
  26.     }
  28.     private void initUI() {
  30.         XYDataset dataset = createDataset();
  31.         JFreeChart chart = createChart(dataset);
  32.         ChartPanel chartPanel = new ChartPanel(chart);
  33.         chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
  34.         chartPanel.setBackground(Color.white);
  35.         add(chartPanel);
  37.         pack();
  38.         setTitle("Line chart");
  39.         setLocationRelativeTo(null);
  40.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  41.     }
  43.     private XYDataset createDataset() {
  45.         XYSeries series1 = new XYSeries("2014");
  46.         series1.add(18, 530);
  47.         series1.add(20, 580);
  48.         series1.add(25, 740);
  49.         series1.add(30, 901);
  50.         series1.add(40, 1300);
  51.         series1.add(50, 2219);
  53.         XYSeries series2 = new XYSeries("2016");
  54.         series2.add(18, 567);
  55.         series2.add(20, 612);
  56.         series2.add(25, 800);
  57.         series2.add(30, 980);
  58.         series2.add(40, 1210);
  59.         series2.add(50, 2350);        
  61.         XYSeriesCollection dataset = new XYSeriesCollection();
  62.         dataset.addSeries(series1);
  63.         dataset.addSeries(series2);
  65.         return dataset;
  66.     }
  68.     private JFreeChart createChart(final XYDataset dataset) {
  70.         JFreeChart chart = ChartFactory.createXYLineChart(
  71.                 "Average salary per age", 
  72.                 "Age", 
  73.                 "Salary (€)", 
  74.                 dataset, 
  75.                 PlotOrientation.VERTICAL,
  76.                 true, 
  77.                 true, 
  78.                 false
  79.         );
  81.         XYPlot plot = chart.getXYPlot();
  83.         XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
  85.         renderer.setSeriesPaint(0, Color.RED);
  86.         renderer.setSeriesStroke(0, new BasicStroke(2.0f));
  88.         renderer.setSeriesPaint(1, Color.BLUE);
  89.         renderer.setSeriesStroke(1, new BasicStroke(2.0f));        
  91.         plot.setRenderer(renderer);
  92.         plot.setBackgroundPaint(Color.white);
  94.         plot.setRangeGridlinesVisible(false);
  95.         plot.setDomainGridlinesVisible(false);
  97.         chart.getLegend().setFrame(BlockBorder.NONE);
  99.         chart.setTitle(new TextTitle("Average Salary per Age",
  100.                         new Font("Serif", Font.BOLD, 18)
  101.                 )
  102.         );
  104.         return chart;
  105.     }
  107.     public static void main(String[] args) {
  109.         SwingUtilities.invokeLater(() -> {
  110.             LineChartEx2 ex = new LineChartEx2();
  111.             ex.setVisible(true);
  112.         });
  113.     }
  114. }

该示例绘制具有两个数据系列的折线图。

  1. XYSeries series1 = new XYSeries("2014");
  2. series1.add(18, 530);
  3. series1.add(20, 580);
  4. series1.add(25, 740);
  5. ...

我们创建第一个系列； 其中包含 2014 年的数据。

  1. XYSeries series2 = new XYSeries("2016");
  2. series2.add(18, 567);
  3. series2.add(20, 612);
  4. series2.add(25, 800);
  5. ...

创建第二个数据系列； 其中包含 2016 年的数据。

  1. XYSeriesCollection dataset = new XYSeriesCollection();
  2. dataset.addSeries(series1);
  3. dataset.addSeries(series2);

通过addSeries()方法将系列添加到XYSeriesCollection。

  1. renderer.setSeriesPaint(0, Color.RED);
  2. renderer.setSeriesStroke(0, new BasicStroke(2.0f));
  4. renderer.setSeriesPaint(1, Color.BLUE);
  5. renderer.setSeriesStroke(1, new BasicStroke(2.0f));

一根线涂成红色，另一根线涂成蓝色。

  1. plot.setRangeGridlinesVisible(false);
  2. plot.setDomainGridlinesVisible(false);

网格线已关闭。

JFreeChart 教程 - 图2

图：具有两个系列的折线图

将图表保存到图像

ChartUtilities是 JFreeChart 的工具方法的集合。 它包括将图表转换为图像格式并创建简单的 HTML 图像映射的方法。

LineChartToPNGEx.java

  1. package com.zetcode.linecharttopngex;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import org.jfree.chart.ChartFactory;
  6. import org.jfree.chart.ChartUtilities;
  7. import org.jfree.chart.JFreeChart;
  8. import org.jfree.chart.plot.PlotOrientation;
  9. import org.jfree.data.xy.XYSeries;
  10. import org.jfree.data.xy.XYSeriesCollection;
  12. public class LineChartToPNGEx {
  14.     public static void main(String[] args) throws IOException {
  16.         XYSeries series1 = new XYSeries("2014");
  17.         series1.add(18, 530);
  18.         series1.add(20, 580);
  19.         series1.add(25, 740);
  20.         series1.add(30, 901);
  21.         series1.add(40, 1300);
  22.         series1.add(50, 2219);
  24.         XYSeriesCollection dataset = new XYSeriesCollection();
  25.         dataset.addSeries(series1);
  27.         JFreeChart chart = ChartFactory.createXYLineChart(
  28.                 "Average salary per age", 
  29.                 "Age", 
  30.                 "Salary (€)", 
  31.                 dataset, 
  32.                 PlotOrientation.VERTICAL,
  33.                 true, 
  34.                 true, 
  35.                 false 
  36.         );
  38.         ChartUtilities.saveChartAsPNG(new File("line_chart.png"), chart, 450, 400);
  39.     }
  40. }

该示例创建一个折线图并将其保存到 PNG 文件中。

  1. ChartUtilities.saveChartAsPNG(new File("line_chart.png"), chart, 450, 400);

ChartUtilities.saveChartAsPNG()将图表保存为 PNG 格式的指定文件。

JFreeChart 区域图

区域图以图形方式显示随时间变化的定量数据。 在 JFreeChart 中使用ChartFactory.createAreaChart()方法创建面积图。

AreaChartEx.java

  1. package com.zetcode.areachartex;
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import javax.swing.BorderFactory;
  6. import javax.swing.JFrame;
  7. import javax.swing.SwingUtilities;
  8. import org.jfree.chart.ChartFactory;
  9. import org.jfree.chart.ChartPanel;
  10. import org.jfree.chart.JFreeChart;
  11. import org.jfree.chart.plot.CategoryPlot;
  12. import org.jfree.chart.plot.PlotOrientation;
  13. import org.jfree.chart.renderer.AreaRendererEndType;
  14. import org.jfree.chart.renderer.category.AreaRenderer;
  15. import org.jfree.chart.title.TextTitle;
  16. import org.jfree.data.category.CategoryDataset;
  17. import org.jfree.data.general.DatasetUtilities;
  19. public class AreaChartEx extends JFrame {
  21.     public AreaChartEx() {
  23.         initUI();
  24.     }
  26.     private void initUI() {
  28.         CategoryDataset dataset = createDataset();
  30.         JFreeChart chart = createChart(dataset);
  31.         ChartPanel chartPanel = new ChartPanel(chart);
  32.         chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
  33.         chartPanel.setBackground(Color.white);
  34.         add(chartPanel);
  36.         pack();
  37.         setTitle("Area chart");
  38.         setLocationRelativeTo(null);
  39.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  40.     }
  42.     private CategoryDataset createDataset() {
  44.         double[][] data = new double[][]{
  45.             {82502, 84026, 85007, 86216, 85559, 84491, 87672,
  46.                 88575, 89837, 90701}
  47.         };
  49.         CategoryDataset dataset = DatasetUtilities.createCategoryDataset(
  50.                 new String[]{"Oil"}, new String[]{"2004", "2005", "2006",
  51.                     "2007", "2008", "2009", "2010", "2011", "2012", "2013"}, 
  52.                 data
  53.         );
  55.         return dataset;
  56.     }
  58.     private JFreeChart createChart(CategoryDataset dataset) {
  60.         JFreeChart chart = ChartFactory.createAreaChart(
  61.                 "Oil consumption",
  62.                 "Time",
  63.                 "Thousands bbl/day",
  64.                 dataset,
  65.                 PlotOrientation.VERTICAL,
  66.                 false,
  67.                 true,
  68.                 true
  69.         );
  71.         CategoryPlot plot = (CategoryPlot) chart.getPlot();
  72.         plot.setForegroundAlpha(0.3f);
  74.         AreaRenderer renderer = (AreaRenderer) plot.getRenderer();
  75.         renderer.setEndType(AreaRendererEndType.LEVEL);
  77.         chart.setTitle(new TextTitle("Oil consumption",
  78.                 new Font("Serif", java.awt.Font.BOLD, 18))
  79.         );
  81.         return chart;
  82.     }
  84.     public static void main(String[] args) {
  86.         SwingUtilities.invokeLater(() -> {
  87.             AreaChartEx ex = new AreaChartEx();
  88.             ex.setVisible(true);
  89.         });
  90.     }
  91. }

该示例显示了一个区域图，该区域图按年份显示了世界原油消耗量。

  1. double[][] data = new double[][]{
  2.     {82502, 84026, 85007, 86216, 85559, 84491, 87672,
  3.         88575, 89837, 90701}
  4. };
  6. CategoryDataset dataset = DatasetUtilities.createCategoryDataset(
  7.         new String[]{"Oil"}, new String[]{"2004", "2005", "2006",
  8.             "2007", "2008", "2009", "2010", "2011", "2012", "2013"}, 
  9.         data
  10. );

使用DatasetUtilities.createCategoryDataset()方法创建数据集。 与类别关联的类别数据集值。 在我们的示例中，我们有数年与石油消耗有关。

  1. CategoryPlot plot = (CategoryPlot) chart.getPlot();
  2. plot.setForegroundAlpha(0.3f);

我们使用setForegroundAlpha()方法使图表透明。

  1. AreaRenderer renderer = (AreaRenderer) plot.getRenderer();
  2. renderer.setEndType(AreaRendererEndType.LEVEL);

我们调整图表的结尾。

JFreeChart 教程 - 图3

图：面积图

JFreeChart 条形图

条形图显示带有矩形条的分组数据，其长度与它们所代表的值成比例。 条形图可以垂直或水平绘制。

BarChartEx.java

  1. package com.zetcode.barchartex;
  3. import java.awt.Color;
  4. import javax.swing.BorderFactory;
  5. import javax.swing.JFrame;
  6. import javax.swing.SwingUtilities;
  7. import org.jfree.chart.ChartFactory;
  8. import org.jfree.chart.ChartPanel;
  9. import org.jfree.chart.JFreeChart;
  10. import org.jfree.chart.plot.PlotOrientation;
  11. import org.jfree.data.category.CategoryDataset;
  12. import org.jfree.data.category.DefaultCategoryDataset;
  14. public class BarChartEx extends JFrame {
  16.     public BarChartEx() {
  18.         initUI();
  19.     }
  21.     private void initUI() {
  23.         CategoryDataset dataset = createDataset();
  25.         JFreeChart chart = createChart(dataset);
  26.         ChartPanel chartPanel = new ChartPanel(chart);
  27.         chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
  28.         chartPanel.setBackground(Color.white);
  29.         add(chartPanel);
  31.         pack();
  32.         setTitle("Bar chart");
  33.         setLocationRelativeTo(null);
  34.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  35.     }
  37.     private CategoryDataset createDataset() {
  39.         DefaultCategoryDataset dataset = new DefaultCategoryDataset();
  40.         dataset.setValue(46, "Gold medals", "USA");
  41.         dataset.setValue(38, "Gold medals", "China");
  42.         dataset.setValue(29, "Gold medals", "UK");
  43.         dataset.setValue(22, "Gold medals", "Russia");
  44.         dataset.setValue(13, "Gold medals", "South Korea");
  45.         dataset.setValue(11, "Gold medals", "Germany");
  47.         return dataset;
  48.     }
  50.     private JFreeChart createChart(CategoryDataset dataset) {
  52.         JFreeChart barChart = ChartFactory.createBarChart(
  53.                 "Olympic gold medals in London",
  54.                 "",
  55.                 "Gold medals",
  56.                 dataset,
  57.                 PlotOrientation.VERTICAL,
  58.                 false, true, false);
  60.         return barChart;
  61.     }
  63.     public static void main(String[] args) {
  65.         SwingUtilities.invokeLater(() -> {
  66.             BarChartEx ex = new BarChartEx();
  67.             ex.setVisible(true);
  68.         });
  69.     }
  71. }

该代码示例使用条形图显示了 2012 年伦敦每个国家/地区的奥运金牌数量。

  1. DefaultCategoryDataset dataset = new DefaultCategoryDataset();
  2. dataset.setValue(46, "Gold medals", "USA");
  3. dataset.setValue(38, "Gold medals", "China");
  4. dataset.setValue(29, "Gold medals", "UK");
  5. dataset.setValue(22, "Gold medals", "Russia");
  6. dataset.setValue(13, "Gold medals", "South Korea");
  7. dataset.setValue(11, "Gold medals", "Germany");

我们使用DefaultCategoryDataset创建数据集。

  1. JFreeChart barChart = ChartFactory.createBarChart(
  2.         "Olympic gold medals in London",
  3.         "",
  4.         "Gold medals",
  5.         dataset,
  6.         PlotOrientation.VERTICAL,
  7.         false, true, false);

使用ChartFactory.createBarChart()方法创建条形图。

JFreeChart 教程 - 图4

图：条形图

JFreeChart 饼图

饼图是一种圆图，分为多个切片以说明数值比例。 使用 JFreeChart 中的ChartFactory.createPieChart()方法创建一个饼图。

PieChartEx.java

  1. package com.zetcode.piechartex;
  3. import java.awt.Color;
  4. import javax.swing.BorderFactory;
  5. import javax.swing.JFrame;
  6. import javax.swing.SwingUtilities;
  7. import org.jfree.chart.ChartFactory;
  8. import org.jfree.chart.ChartPanel;
  9. import org.jfree.chart.JFreeChart;
  10. import org.jfree.data.general.DefaultPieDataset;
  12. public class PieChartEx extends JFrame {
  14.     public PieChartEx() {
  16.         initUI();
  17.     }
  19.     private void initUI() {
  21.         DefaultPieDataset dataset = createDataset();
  23.         JFreeChart chart = createChart(dataset);
  24.         ChartPanel chartPanel = new ChartPanel(chart);
  25.         chartPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 15, 15));
  26.         chartPanel.setBackground(Color.white);
  27.         add(chartPanel);
  29.         pack();
  30.         setTitle("Pie chart");
  31.         setLocationRelativeTo(null);
  32.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  33.     }
  35.     private DefaultPieDataset createDataset() {
  37.         DefaultPieDataset dataset = new DefaultPieDataset();
  38.         dataset.setValue("Apache", 52);
  39.         dataset.setValue("Nginx", 31);
  40.         dataset.setValue("IIS", 12);
  41.         dataset.setValue("LiteSpeed", 2);
  42.         dataset.setValue("Google server", 1);
  43.         dataset.setValue("Others", 2);
  45.         return dataset;
  46.     }
  48.     private JFreeChart createChart(DefaultPieDataset dataset) {
  50.         JFreeChart barChart = ChartFactory.createPieChart(
  51.                 "Web servers market share",
  52.                 dataset,
  53.                 false, true, false);
  55.         return barChart;
  56.     }
  58.     public static void main(String[] args) {
  60.         SwingUtilities.invokeLater(() -> {
  61.             PieChartEx ex = new PieChartEx();
  62.             ex.setVisible(true);
  63.         });
  64.     }
  65. }

该示例使用饼图来显示 Web 服务器的市场份额。

  1. DefaultPieDataset dataset = new DefaultPieDataset();
  2. dataset.setValue("Apache", 52);
  3. dataset.setValue("Nginx", 31);
  4. dataset.setValue("IIS", 12);
  5. ...

DefaultPieDataset用于创建数据集。

  1. JFreeChart barChart = ChartFactory.createPieChart(
  2.         "Web servers market share",
  3.         dataset,
  4.         false, true, false);

使用ChartFactory.createPieChart()方法创建一个新的饼图。

Servlet 中的 JFreeChart

在以下示例中，我们使用 Java servlet 创建饼图。 该图表在 Web 浏览器中呈现。

DoChart.java

  1. package com.zetcode.servletchart;
  3. import java.awt.BasicStroke;
  4. import java.awt.Color;
  5. import java.io.IOException;
  6. import java.io.OutputStream;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.annotation.WebServlet;
  9. import javax.servlet.http.HttpServlet;
  10. import javax.servlet.http.HttpServletRequest;
  11. import javax.servlet.http.HttpServletResponse;
  12. import org.jfree.chart.ChartFactory;
  13. import org.jfree.chart.ChartUtilities;
  14. import org.jfree.chart.JFreeChart;
  15. import org.jfree.data.general.DefaultPieDataset;
  17. @WebServlet(name = "DoChart", urlPatterns = {"/DoChart"})
  18. public class DoChart extends HttpServlet {
  20.     @Override
  21.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  22.             throws ServletException, IOException {
  24.         response.setContentType("image/png");
  26.         OutputStream outputStream = response.getOutputStream();
  28.         JFreeChart chart = getChart();
  29.         int width = 500;
  30.         int height = 350;
  32.         ChartUtilities.writeChartAsPNG(outputStream, chart, width, height);
  33.     }
  35.     public JFreeChart getChart() {
  37.         DefaultPieDataset dataset = new DefaultPieDataset();
  38.         dataset.setValue("Croatia", 22);
  39.         dataset.setValue("Bohemia", 34);
  40.         dataset.setValue("Bulgaria", 18);
  41.         dataset.setValue("Spain", 5);
  42.         dataset.setValue("Others", 21);
  44.         JFreeChart chart = ChartFactory.createPieChart("Popular destinations", 
  45.                 dataset, true, false, false);
  47.         chart.setBorderVisible(false);
  49.         return chart;
  50.     }
  51. }

DoChart Servlet 创建一个饼图并将其发送到客户端。

  1. response.setContentType("image/png");

setContentType()将内容设置为 PNG 图像。

  1. OutputStream outputStream = response.getOutputStream();

使用getOutputStream()方法，我们得到一个输出流。 这是我们向其发送数据的隧道。

  1. ChartUtilities.writeChartAsPNG(outputStream, chart, width, height);

ChartUtilities.writeChartAsPNG()将二进制数据写入输出字符串。

JFreeChart 教程 - 图5

图：浏览器中的饼图

显示来自 MySQL 数据库的数据

JDBCCategoryDataset是对数据库 JDBC 结果集的CategoryDataset实现。 通过使用字符串 SQL 查询调用executeQuery()来填充数据集。

medals.sql

  1. DROP TABLE IF EXISTS GoldMedalsLondon;
  3. CREATE TABLE GoldMedalsLondon (
  4.   Id int(11) NOT NULL AUTO_INCREMENT,
  5.   Country text,
  6.   Medals int(11) DEFAULT NULL,
  7.   PRIMARY KEY (Id)
  8. ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=latin1;
  10. LOCK TABLES GoldMedalsLondon WRITE;
  11. INSERT INTO GoldMedalsLondon VALUES (1,'USA',46),(2,'China',38),(3,'UK',29),
  12.   (4,'Russia',22),(5,'South Korea',13),(6,'Germany',11);
  13. UNLOCK TABLES;

我们将这些数据存储在 MySQL 数据库表中。

  1. mysql> SELECT * FROM GoldMedalsLondon;
  2. +----+-------------+--------+
  3. | Id | Country     | Medals |
  4. +----+-------------+--------+
  5. |  1 | USA         |     46 |
  6. |  2 | China       |     38 |
  7. |  3 | UK          |     29 |
  8. |  4 | Russia      |     22 |
  9. |  5 | South Korea |     13 |
  10. |  6 | Germany     |     11 |
  11. +----+-------------+--------+
  12. 6 rows in set (0.00 sec)

我们使用mysql工具显示数据。

MySQLChartEx.java

  1. package com.zetcode.mysqlchartex;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.sql.Connection;
  6. import java.sql.DriverManager;
  7. import java.sql.SQLException;
  8. import org.jfree.chart.ChartFactory;
  9. import org.jfree.chart.ChartUtilities;
  10. import org.jfree.chart.JFreeChart;
  11. import org.jfree.chart.plot.PlotOrientation;
  12. import org.jfree.data.jdbc.JDBCCategoryDataset;
  14. public class MySQLChartEx {
  16.     private static JDBCCategoryDataset dataset;
  18.     public static void main(String[] args) throws IOException, SQLException {
  20.         Connection con = null;
  22.         String url = "jdbc:mysql://localhost:3306/testdb";
  23.         String user = "testuser";
  24.         String password = "test623";
  26.         try {
  28.             con = DriverManager.getConnection(url, user, password);
  29.             dataset = new JDBCCategoryDataset(con);
  30.             dataset.executeQuery("SELECT Country, Medals FROM GoldMedalsLondon");
  32.         } finally {
  34.             if (con != null) {
  35.                 con.close();
  36.             }
  37.         }
  39.         JFreeChart barChart = ChartFactory.createBarChart(
  40.                 "Olympic Gold medals in London",
  41.                 "",
  42.                 "Gold medals",
  43.                 dataset,
  44.                 PlotOrientation.VERTICAL,
  45.                 false, true, false);
  47.         ChartUtilities.saveChartAsPNG(new File("medals.png"), barChart, 450, 400);
  48.     }
  49. }

该示例从 MySQL 表检索数据，创建条形图，然后将其保存到 PNG 图像中。

  1. con = DriverManager.getConnection(url, user, password);
  2. dataset = new JDBCCategoryDataset(con);

JDBCCategoryDataset已创建； 它以数据库连接为参数。

  1. dataset.executeQuery("SELECT Country, Medals FROM GoldMedalsLondon");

executeQuery()通过针对现有数据库连接执行提供的查询来填充数据集。 SQL 查询必须至少返回两列。 第一列是类别名称，其余列是值。

  1. JFreeChart barChart = ChartFactory.createBarChart(
  2.         "Olympic Gold medals in London",
  3.         "",
  4.         "Gold medals",
  5.         dataset,
  6.         PlotOrientation.VERTICAL,
  7.         false, true, false);

条形图已创建。

  1. ChartUtilities.saveChartAsPNG(new File("medals.png"), barChart, 450, 400);

条形图通过ChartUtilities.saveChartAsPNG()方法保存到 PNG 文件中。

本教程专门针对 JFreeChart 库。 您可能也对相关教程感兴趣： Java Swing 教程， Java 2D 教程， Java PDFBox 教程或 Java 教程。 也可以在 JavaFX 中创建图表。