JFreeChart is a powerful open source chart library for Java. It offers a wide range of features that can be used to create different types of charts including line graphs, bar charts, pie charts, and more. JFreeChart is used in many different applications and is a great choice for creating custom chart solutions.
Audience
This tutorial is intended for developers and data scientists who are interested in learning more about creating graphs and charts using JFreeChart. It should be suitable for both novice and experienced users. The tutorial covers topics such as creating basic and advanced charts, customizing the look and feel of the charts, and working with datasets. It also provides tips and tricks for creating more effective graphs.
Prerequisites
This JFreeChart tutorial assumes that the reader has some basic knowledge of Java programming language. If you are new to Java, then check out our Java Tutorials and Java EE Tutorials.
JFreeChart – Overview
JFreeChart is a free and open-source Java library for creating charts and graphs. It is used to create a wide variety of charts, including pie charts, bar charts, line graphs, histograms, scatter plots, and more. It also supports dynamic updates, animation, and event handling. It is available as a library under the GNU LGPL license, and can be used in both commercial and non-commercial applications. JFreeChart is designed to be easy to use, and is backed by a strong community of users who are available to provide support and assistance. It is also integrated with other Java libraries, such as Swing and SWT, making it easy to create applications with rich graphical user interfaces.
Why JFreeChart?
JFreeChart is a popular open source charting library for Java. It is used to create a wide variety of charts, such as pie charts, bar charts, line charts, and scatter plots. It is easy to use and provides a high degree of customization. It also provides a wide range of features, such as support for multiple data sources, interactive features, and integrated support for JavaFX. JFreeChart also offers a range of tools for data analysis, such as statistical analysis and regression analysis.
Getting Started
To get started with JFreeChart, you will need to download the JFreeChart library from the JFreeChart website. Once you have downloaded the library, you will need to add it to your project’s classpath. You can do this by adding the JFreeChart library jar file to the project’s build path.
Creating a Chart
Once you have the JFreeChart library in your project, you can start creating charts. To create a chart in JFreeChart, you need to create a ChartFactory instance and then use it to create a chart. When creating a chart, you can specify the chart type, the data you want to display, and any other options you require.
Displaying a Chart
Once you have created a chart, you can display it using a ChartPanel. A ChartPanel is a Swing component that displays a chart. You can customize the ChartPanel by setting the size, the background color, and other options. You can also add the ChartPanel to a frame or panel in your application.
Customization
JFreeChart provides a number of options for customizing charts. You can customize the look and feel of charts by setting the colors, fonts, and other options. You can also add annotations and other elements to charts. Additionally, JFreeChart provides a number of themes that allow you to quickly change the look and feel of charts.
Conclusion
JFreeChart is a powerful chart library for Java that provides an easy way to create charts for your applications. It is easy to get started with JFreeChart and it provides a number of options for customizing charts. With JFreeChart, you can create a wide range of different types of charts and quickly change the look and feel of your charts.
JFreeChart – Installation
1. Download and install the latest version of JFreeChart from the official website.
2. Add the JFreeChart JAR to your classpath.
3. Create a Java project in your favorite IDE or text editor and add the JFreeChart JAR to the project’s build path.
4. Download the jcommon.jar from the JFreeChart download page and add it to your project’s build path.
5. Create a new class and import the JFreeChart packages you want to use.
6. Create a chart using the JFreeChart API.
7. Use the ChartPanel class to display the chart in a frame or panel.
JFreeChart – Architecture
JFreeChart is an open source, Java-based charting library. It provides a wide variety of charts and graphs, ranging from basic bar and line charts to more complex pie and 3D plots.
The architecture of JFreeChart is based on a modular design. It is composed of several components that can be used independently or combined to create more complex charts and graphs.
At the core of JFreeChart is the ChartFactory, which is responsible for creating charts from a given dataset. Once a chart is created, the ChartPanel class provides a Java Swing-based UI for displaying it. ChartPanel also provides a range of user interaction features such as zooming and panning.
JFreeChart also includes a number of plot classes, such as CategoryPlot, PiePlot, and XYPlot. These classes are responsible for drawing the actual data on the plot. There are also several renderers, such as XYLineAndShapeRenderer and XYBarRenderer, which are responsible for rendering data points and other plot elements.
In addition, JFreeChart includes several chart styles, such as the StandardPieChart and StandardBarChart. These styles allow users to quickly create a chart without needing to write any code.
Finally, JFreeChart also provides some supporting classes such as ChartUtilities, which provides utilities for saving charts as images and for printing charts.
Class Level Architecture
The class level architecture of JFreeChart includes the following classes:
1. ChartFactory: This class contains methods for creating various types of charts.
2. ChartPanel: This is a Swing component for displaying charts.
3. ChartUtilities: This class contains utility methods for generating chart images.
4. ChartTheme: This class is used to define the look and feel of a chart.
5. DefaultValueDataset: This class is used to store and retrieve data for a chart.
6. Plot: This class is used to define the plot for a chart.
7. CategoryPlot: This class is used to define a plot for a category chart.
8. XYPlot: This class is used to define the plot for an XY chart.
9. PiePlot: This class is used to define the plot for a pie chart.
10. AbstractRenderer: This class is used to define a renderer, which is responsible for drawing the data elements of a chart.
11. CategoryAxis: This class is used to define the x-axis for a category chart.
12. ValueAxis: This class is used to define the y-axis for an XY chart.
13. PieSectionLabelGenerator: This class is used to generate labels for pie sections.
14. DefaultPieDataset: This class is used to store and retrieve data for a pie chart.
Application Level Architecture
1. Database Layer: This layer is responsible for storing, retrieving and manipulating data in the database. It uses JDBC APIs to connect to the database and perform read/write operations.
2. Business Logic Layer: This layer contains the business logic of the application. It is responsible for validating the data and performing calculations.
3. Presentation Layer: This layer is responsible for displaying the data in charts and graphs. It uses the JFreeChart library to generate charts and graphs from the data.
4. User Interface Layer: This layer is responsible for building the user interface of the application. It uses Swing and AWT components to create the user interface.
5. Security Layer: This layer is responsible for authenticating the user and providing authorization. It uses security protocols such as OAuth and SAML to authenticate the user.
JFreeChart – Referenced APIs
1. Java Platform Standard Edition (Java SE)
2. Java Servlet API
3. Java Database Connectivity (JDBC)
4. Java Advanced Imaging (JAI)
5. JavaFX
6. JavaBeans Activation Framework (JAF)
7. Java 2D Graphics API
8. Java3D
9. Swing
10. Java2D
11. HTML Parser Library
12. Apache Commons Math
ChartFactory Class
The JFreeChartFactory class is a utility class used to create a variety of charts. It contains static methods for creating different types of charts including pie charts, bar charts, line charts, and more. The class also contains methods for customizing the chart with titles, labels, and other chart elements. The charts created by this class are compatible with the JFreeChart library.
ChartFrame Class
The TimeSeriesChartFrame class is a Java Swing application that provides a graphical interface for creating and manipulating time series charts. It is part of the JFreeChart library, a charting library for Java applications. The TimeSeriesChartFrame class provides a visual way to create and modify time series charts, which are useful for visualizing data over time. The TimeSeriesChartFrame class allows users to customize the appearance of their charts, including the type of chart, the colors used, the data points, the labels and titles, and more. The TimeSeriesChartFrame class also provides a wide range of interactive features, such as zooming, panning, and selecting specific data points.
ChartPanel Class
The org.jfree.chart.ChartPanel class is a GUI component for displaying a JFreeChart object. It can be used in Java Swing applications, Java applets, and Java web applications. It supports mouse-based interactions such as zooming, panning, selection, and displaying tooltips. It also provides a popup menu for changing the display settings and saving the chart to disk.
ChartUtilities Class
The org.jfree.chart.ChartUtilities class provides utility methods for saving charts in a variety of output formats, including PNG and JPEG. It can be used to generate an image of a chart, or to write an image map for HTML image maps. It can also be used to write an SVG (Scalable Vector Graphics) file for inclusion in an SVG supporting document.
JFreeChart Class
JFreeChart is a popular Java charting library that can be used to generate a wide variety of charts, including pie, bar, line, Gantt, and scatter charts. It is easy to use and provides comprehensive support for creating charts from various data sources. It also supports customization of chart elements such as titles, fonts, colors, and axes. JFreeChart is released under the GNU LGPL license.
PiePlot Class
The PiePlot class is a subclass of the Plot class in the JFreeChart library. It is used to create pie charts which are a type of statistical graphic which display data as a proportion of the whole. This class offers a wide range of features and customization options, including customizable labels and colors, as well as methods for adding, removing and changing data points. PiePlot also provides support for tooltip and popup menu customization.
PiePlot3D Class
The PiePlot3D class is a subclass of the PiePlot class in the JFreeChart library. It is used to create a 3D pie chart from a set of data values. The class supports the ability to rotate the chart and to create a ‘exploded’ slice effect. It also supports the ability to change the colour of each data point. The PiePlot3D class is a powerful tool for visualizing data in a three dimensional way.
PlotOrientation Class
The PlotOrientation class is a Java class from the JFreeChart library that defines the orientation of a chart plot. It has two constants, HORIZONTAL and VERTICAL. These constants can be used to set the orientation of a chart plot to either horizontal or vertical. This class is used when creating a new chart instance, which is then used to plot data.
XYPlot Class
The XYPlot class is a subclass of the Plot class in the JFreeChart library. It is used to create two-dimensional charts, such as line charts, scatter plots, and area charts. It is similar to the CategoryPlot class, which is used to create three-dimensional charts. The XYPlot class can be used to customize the appearance of the chart, including the background, axes, legend, and data points. It also provides a number of methods for adding, removing and manipulating the data.
NumberAxis Class
The NumberAxis class in JFreeChart is a subclass of ValueAxis and is used for plotting numerical data on a chart. It allows for the scaling, labeling, and positioning of the data in a chart. It also provides features such as auto-scaling and auto-labeling of data points. NumberAxis can be used to create charts such as line and bar charts.
XYLineAndShapeRenderer Class
The XYLineAndShapeRenderer class is a renderer that combines features of the XYLineRenderer and XYShapeRenderer classes. This renderer can draw lines, shapes, and symbols at the same time on an XYPlot. It can also draw shapes that have been filled with a color or pattern. This class provides a lot of flexibility when it comes to customizing visualizations and it is a great choice for scatter plots or other types of data that require both lines and shapes.
XYItemRenderer general datasets
XYItemRenderer is an interface that is used in JFreeChart to create renderers for XY-based datasets. These renderers are used to represent data on the graph in a variety of ways, such as line plots, area plots, scatter plots, and more. The XYItemRenderer interface provides methods to customize how data points are displayed, such as setting line widths, colors, and point shapes. The XYItemRenderer also provides support for customizing the appearance of markers, such as setting the marker size and shape.
PieDataset
PieDataset is an interface in JFreeChart used to represent a dataset in the form of a pie chart. It is implemented by various classes like DefaultPieDataset, CategoryToPieDataset, and PieDatasetUtilities. PieDataset can be used to create a pie chart that displays values from the dataset in the form of a pie. Pie charts are useful for displaying data in a visually appealing way, and can be used to compare values and compare different categories of data.
DefaultPieDataset Class
org.jfree.data.general.DefaultPieDataset is a class in JFreeChart. It is used to create a default dataset for pie charts and is a subclass of AbstractDataset. This class allows data to be stored in the form of keys and values, where the keys are used to identify the data and the values are the actual data. It also provides methods to add values, remove values, and get values. The data in this class can be used for creating pie charts, which are a type of graph that can be used to represent data in the form of proportions or percentages.
SeriesException Class
The org.jfree.data.general.SeriesException class is a subclass of the RuntimeException class in the JFreeChart library. It is used to indicate an exceptional condition that has occurred when processing a series of data points. This exception is typically thrown when a problem is encountered while trying to access, modify, or add data points to a series.
DefaultCategoryDataset
DefaultCategoryDataset is a class used in JFreeChart to represent a dataset with values associated with categories. It is a subclass of the CategoryDataset interface. It is an implementation of the CategoryDataset interface, where the data is stored in an array of Values objects, each containing an array of Comparable objects representing the series and an array of Number objects representing the data values. It supports a flexible number of series and data items, and supports data values of any type for which an appropriate Number subclass is available.
Time Series
JFreeChart is a powerful and flexible open source Java library for creating a wide variety of charts, including time series charts. It offers a wide range of customization options and supports a variety of data sources, including CSV files, Excel spreadsheets, and databases. It is easy to use and provides a range of charts, including line charts, bar charts, pie charts, and scatter plots. It also includes features such as zooming, panning, and annotations, as well as a variety of built-in chart types. With JFreeChart, you can easily create professional-looking time series charts that help you to visualize your data and make more informed decisions.
TimeSeriesCollection
A TimeSeriesCollection is a type of dataset used in JFreeChart for plotting time series graphs. It is a collection of time series objects, each of which can contain a set of data items for plotting. The TimeSeriesCollection is the main mechanism for storing and manipulating data in the JFreeChart library.
Frames in JFreeCharts
JFreeChart is a popular Java library for creating charts and graphs. It supports a wide range of chart types, including pie charts, bar charts, line graphs, scatter plots, histograms, and more. It also supports frames, which are defined as a group of charts that are displayed together on a single page. Frames can be used to create multi-panel charts or to compare different datasets. Frames can also be used to display multiple charts side-by-side or as a single page with multiple panels.
ApplicationFrame
JFrameApplication is an abstract class in the JFreeChart library which provides a basic framework for applications. It provides a window which can be used to display charts and other components. It also provides a menu bar and toolbar, and allows the user to customize the look and feel of the application. JFrameApplication is a useful starting point for creating custom applications using JFreeChart.
RefineryUtilities
RefineryUtilities is a class in the JFreeChart library that contains several static utility methods that are useful for creating charts. It contains methods for creating XYPlot objects, setting up a chart theme, creating a legend, and more.
JFreeChart – Pie Chart
JFreeChart is a popular open source library for creating pie charts. It is written in Java and can be used in Java-based applications to generate a wide variety of charts, including pie charts. It has a comprehensive API that allows developers to customize the appearance and behavior of the pie chart. It also supports animation and can be used to create interactive charts. JFreeChart is free to use and is widely used by businesses and developers.
AWT Based Application
AWT stands for Abstract Window Toolkit. It is a set of classes provided by Java, which are used to create Graphical User Interfaces (GUIs) that are portable across different platforms. It is the foundation of the Swing GUI library and provides basic GUI functionality such as buttons, text fields and windows.
This code helps you to embed a pie chart in any AWT based application.
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Font;
public class PieChart {
public static void drawPieChart(Graphics g, int[] data, Color[] colors, int startAngle, int x, int y, int width, int height) {
int total = 0;
for (int i = 0; i < data.length; i++) {
total += data[i];
}
int currentAngle = startAngle;
for (int i = 0; i < data.length; i++) {
int arcAngle = (int) (data[i] * 360.0 / total);
g.setColor(colors[i]);
g.fillArc(x, y, width, height, currentAngle, arcAngle);
currentAngle += arcAngle;
}
g.setColor(Color.BLACK);
g.setFont(new Font(“SansSerif”, Font.BOLD, 20));
g.drawString(“Pie Chart”, x + (width / 2) – 40, y + (height / 2) + 10);
}
}
JPEG Image Creation
JPEG image creation involves the use of a digital imaging software such as Photoshop or GIMP to create an image in the JPEG file format. This type of image creation involves taking digital photographs or scanning in existing images, and then editing them using the software to adjust the size, color, contrast and other aspects of the image. Once the desired effects have been achieved, the image can be saved as a JPEG file, which can then be shared online or printed.
JFreeChart – Bar Chart
JFreeChart is a free Java chart library for creating a wide variety of charts, including bar charts. Bar charts can be used to compare different sets of data or show changes over time. They can also be used to compare different categories or to show relationships between different variables. Bar charts are created using the JFreeChart class, which provides a wide range of customization options to create charts that meet the needs of the user.
AWT Based Application
This code helps you to embed a bar chart in any AWT based application.
import java.awt.*;
import javax.swing.*;
import org.jfree.chart.*;
import org.jfree.data.category.*;
public class BarChartEmbedder {
public static void embedBarChart(Container container, double[][] data,
String[] categoryNames, String chartTitle,
String xAxisLabel, String yAxisLabel) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data[i].length; j++) {
dataset.addValue(data[i][j], categoryNames[i], Integer.toString(j));
}
}
JFreeChart chart = ChartFactory.createBarChart3D(
chartTitle, xAxisLabel, yAxisLabel, dataset);
ChartPanel chartPanel = new ChartPanel(chart);
container.add(chartPanel, BorderLayout.CENTER);
}
}
JFreeChart – Line Chart
JFreeChart is a free and open source library for creating line charts and other types of charts in Java. It is a versatile library that can be used to create simple or complex charts, and has a wide range of features and customization options. It includes an extensive set of chart types, including line, bar, area, pie, and scatter charts. It also supports various chart types such as XY, XYZ, and more. Additionally, it can be used to create interactive charts with interactive features such as zooming and panning.
AWT Based Application
This code helps you to embed a line chart in any AWT based application.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
public class LineChartExample extends JFrame {
public LineChartExample() {
// Create dataset
DefaultPieDataset dataset = new DefaultPieDataset();
dataset.setValue(“One”, new Double(20));
dataset.setValue(“Two”, new Double(20));
dataset.setValue(“Three”, new Double(40));
dataset.setValue(“Four”, new Double(10));
// Create chart
JFreeChart chart = ChartFactory.createLineChart(
“Line Chart Example”,
“Categories”, “Values”, dataset);
// Create Panel
ChartPanel panel = new ChartPanel(chart);
setContentPane(panel);
}
public static void main(String[] args) {
LineChartExample example = new LineChartExample();
example.setSize(800, 400);
example.setLocationRelativeTo(null);
example.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
example.setVisible(true);
}
}
JFreeChart – XY Chart
JFreeChart is a free, open source charting library for the Java platform. It is capable of creating a variety of charts, including XY charts. XY charts are used to display data points on a two-dimensional graph, with one variable on the x-axis and the other variable on the y-axis. JFreeChart provides a wide range of features for creating XY charts, including the ability to display multiple datasets, customize chart elements such as axes and labels, and add annotations and legends. Additionally, it provides support for multiple chart types, including line, scatter, and area charts.
AWT Based Application
This code helps you to embed an XY chart in any AWT based application. It uses the AWT Chart library to create a XY chart and add it to the AWT application. The code takes the data points from user defined arrays and adds them to the chart. The chart is then displayed on the AWT Frame.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import org.jfree.chart.*;
import org.jfree.chart.axis.*;
import org.jfree.chart.plot.*;
import org.jfree.data.xy.*;
public class EmbedXYChart {
public static void main (String[] args) {
// Create the data points for the XY chart
double[] x = {1.2, 2.4, 3.6, 4.8, 6.0};
double[] y = {2.4, 4.8, 7.2, 9.6, 12.0};
// Create the XYChart object using the data points
XYSeries series = new XYSeries(“Data”);
for (int i = 0; i < x.length; i++) {
series.add(x[i], y[i]);
}
XYSeriesCollection data = new XYSeriesCollection(series);
// Create the chart object, set the chart title and axis labels
JFreeChart chart = ChartFactory.createXYLineChart(“XY Chart”, “X-Axis”, “Y-Axis”, data, PlotOrientation.VERTICAL, true, true, false);
// Create the AWT Frame and add the chart to it
Frame frame = new Frame();
frame.add(new ChartPanel(chart), BorderLayout.CENTER);
frame.pack();
frame.setVisible(true);
}
}
JFreeChart – 3D Pie/Bar Chart
JFreeChart is an open source library for creating a variety of charts, including 3D Pie and Bar Charts. It supports multiple platforms and can be used in applications written in Java, as well as other languages such as C# and Python. It offers a wide range of features, including sophisticated chart types, customizable axes and legends, and a large selection of colors and fonts. With JFreeChart, users can create interactive charts with drill down capabilities and support for multiple datasets. It also supports animation, export to a variety of formats, and integration with other libraries such as Apache POI and iText.
AWT Based Application
This code helps you to embed a pie chart in any AWT based application.
import java.awt.Color;
import java.awt.Graphics;
public class PieChart {
public static void drawPieChart(Graphics g, int radius, int x, int y, double[] values, Color[] colors) {
double totalValue = 0.0D;
for (int i = 0; i < values.length; i++) {
totalValue += values[i];
}
int startAngle = 0;
for (int i = 0; i < values.length; i++) {
int arcAngle = (int) (values[i] / totalValue * 360);
g.setColor(colors[i]);
g.fillArc(x, y, radius, radius, startAngle, arcAngle);
startAngle += arcAngle;
}
}
}
3D Bar Chart
3D bar charts can be created in Jfreechart with the help of the CategoryPlot class. This class allows users to create a 3D bar chart by adding a third dimension to the chart. To create a 3D bar chart, users need to create a CategoryPlot object and then add a BarRenderer3D to the plot. The BarRenderer3D class can be used to customize the look and feel of the 3D bar chart including colors, labels, and fonts. Additionally, users can also customize the chart’s axes with the help of the ValueAxis class.
AWT based application
This code helps you to embed a bar chart in any AWT based application.
import java.awt.*;
import javax.swing.*;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
public class BarChart {
public static void addBarChart(Container contentPane, String chartTitle, String xAxisLabel, String yAxisLabel, String[] categories, double[] values) {
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
for (int i=0; i<categories.length; i++) {
dataset.addValue(values[i], “”, categories[i]);
}
JFreeChart chart = ChartFactory.createBarChart(
chartTitle, xAxisLabel, yAxisLabel, dataset,
PlotOrientation.VERTICAL, false, true, false);
ChartPanel chartPanel = new ChartPanel(chart);
contentPane.add(chartPanel);
}
}
JFreeChart – Bubble Chart
JFreeChart is a free and open source charting library for the Java platform. It is a popular charting library for creating Bubble Charts, which are a type of chart that displays data points as circles, with the size of the circle representing the value of the data point. Bubble Charts are useful for displaying correlations between two or three variables, and can be used to compare the relative sizes of data points.
AWT Based Application
This code helps you to embed a Bubble chart in any AWT based application.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.Random;
public class BubbleChart extends JPanel {
//declare data array
double[][] data;
//declare color array
Color[] colors;
//declare random object
Random rand = new Random();
//constructor
public BubbleChart(double[][] data, Color[] colors) {
this.data = data;
this.colors = colors;
}
//override paintComponent method
public void paintComponent(Graphics g) {
super.paintComponent(g);
//initialize variables
int width = getWidth();
int height = getHeight();
int maxX = 0;
int maxY = 0;
int maxRadius = 0;
//calculate maxX, maxY and maxRadius
for (int i = 0; i < data.length; i++) {
if (data[i][0] > maxX)
maxX = (int) data[i][0];
if (data[i][1] > maxY)
maxY = (int) data[i][1];
if (data[i][2] > maxRadius)
maxRadius = (int) data[i][2];
}
//calculate scale
double xScale = (width – 40) / (double) maxX;
double yScale = (height – 40) / (double) maxY;
double radiusScale = (width – 40) / (2 * (double) maxRadius);
//draw bubbles
for (int i = 0; i < data.length; i++) {
int x = (int) (20 + data[i][0] * xScale);
int y = (int) (20 + (maxY – data[i][1]) * yScale);
int radius = (int) (data[i][2] * radiusScale);
g.setColor(colors[i % colors.length]);
g.fillOval(x – radius, y – radius, 2 * radius, 2 * radius);
}
}
//main method
public static void main(String[] args) {
//create frame
JFrame frame = new JFrame(“Bubble Chart”);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);
//create data array
double[][] data = new double[10][3];
for (int i = 0; i < 10; i++) {
data[i][0] = Math.random() * 100;
data[i][1] = Math.random() * 100;
data[i][2] = Math.random() * 10 + 10;
}
//create color array
Color[] colors = {Color.RED, Color.BLUE, Color.GREEN, Color.YELLOW};
//create chart and add to frame
BubbleChart chart = new BubbleChart(data, colors);
frame.add(chart);
frame.setVisible(true);
}
}
JFreeChart – TimeSeries Chart
JFreeChart is a popular library used for creating charts in Java. It includes a wide range of chart types, including line charts, bar charts, pie charts, scatter charts, histograms, time series charts, and more. TimeSeries charts are used to display data in chronological order. They plot data points connected by lines and can be used to display trends over time. TimeSeries charts are commonly used to analyze stock market performance, show the growth of a business, or compare different metrics over a period of time.
AWT Based Application
Following is the code to create Time Series Chart from the numbers generated by Math.random() at a given time internal.
<script type=”text/javascript”>
// Generate random numbers
var randomNumbers = [];
for (var i = 0; i < 10; i++) {
randomNumbers.push(Math.random());
}
// Set up the chart
var ctx = document.getElementById(‘myChart’).getContext(‘2d’);
var chart = new Chart(ctx, {
type: ‘line’,
data: {
labels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
datasets: [{
label: ‘Random Numbers’,
data: randomNumbers,
backgroundColor: ‘rgba(255, 99, 132, 0.2)’,
borderColor: ‘rgba(255, 99, 132, 1)’,
borderWidth: 1
}]
},
options: {
scales: {
yAxes: [{
ticks: {
beginAtZero: true
}
}]
}
}
});
</script>
JFreeChart – File Interface
JFreeChart provides a file interface that allows users to save their charts in a variety of formats. This includes support for PNG, JPEG, PDF and SVG formats. Additionally, JFreeChart can also export charts to HTML, XML, and CSV formats. The exported file can be used in other applications and websites. The file interface also allows users to print their charts directly to a printer. This feature is useful when presenting the data in a meeting or conference.
Chart Generation Based on File
following is the code to create a Pie Chart based on the information provided in mobile.txt
import matplotlib.pyplot as plt
data = open(‘mobile.txt’, ‘r’)
labels = []
sizes = []
for line in data:
label, size = line.split(‘:’)
labels.append(label)
sizes.append(int(size))
plt.pie(sizes, labels=labels, autopct=’%1.1f%%’, shadow=True, startangle=90)
plt.axis(‘equal’)
plt.show()
JFreeChart – Database Interface
JFreeChart is a popular library for creating professional-looking charts and graphs. It includes an extensive library of chart types and features, and provides a simple way to connect to and display data from a variety of databases. The library supports a wide range of databases, including MySQL, Oracle, PostgreSQL, SQLite, Microsoft SQL Server, and others. It also provides a database interface that simplifies the process of connecting to and querying data from a database. The database interface allows users to connect to and query databases using a variety of methods, including JDBC and ODBC drivers. Additionally, the interface allows users to create custom queries and access data from multiple databases.
Chart Generation Using Database
Following is the code to create a Pie Chart
<script>
// Load the Visualization API and the corechart package.
google.charts.load(‘current’, {‘packages’:[‘corechart’]});
// Set a callback to run when the Google Visualization API is loaded.
google.charts.setOnLoadCallback(drawChart);
// Callback that creates and populates a data table,
// instantiates the pie chart, passes in the data and
// draws it.
function drawChart() {
// Create the data table.
var data = new google.visualization.DataTable();
data.addColumn(‘string’, ‘Topping’);
data.addColumn(‘number’, ‘Slices’);
data.addRows([
[‘Mushrooms’, 3],
[‘Onions’, 1],
[‘Olives’, 1],
[‘Zucchini’, 1],
[‘Pepperoni’, 2]
]);
// Set chart options
var options = {‘title’:’How Much Pizza I Ate Last Night’,
‘width’:400,
‘height’:300};
// Instantiate and draw our chart, passing in some options.
var chart = new google.visualization.PieChart(document.getElementById(‘chart_div’));
chart.draw(data, options);
}
</script>
<div id=”chart_div”></div>