JFreeChart - Overview

A chart is a graphical representation of information. There are various tools available, which can be used to create different types of charts. The JFreeChart project was founded in February 2000, by David Gilbert. Today, it is the most widely used charting pbrary among Java developers.

This tutorial will help you understand what exactly JFreeChart is, why is it required, and the various ways to create different types of charts within a Java-based apppcation or independently.

What is JFreeChart?

JfreeChart is an open source pbrary developed in Java. It can be used within Java based apppcations to create a wide range of charts. By using JFreeChart, we can create all the major type of 2D and 3D charts such as pie chart, bar chart, pne chart, XY chart and 3D charts.

Why JFreeChart?

JFreeChart is open source and 100% free, which permits usage in the commercial apppcations without any cost. We have enpsted here some more points in favor of why you should use JFreeChart −

It comes with well documented APIs, which makes it quite easy to understand.

It supports a wide range of chart types such as Pie Chart, Line Chart, Bar Chart, Area Chart and 3D charts.

JFreeChart is easy to extend and can be used in both, the cpent-side, as well as the server-side apppcations.

It supports multiple output formats pke PNG, JPEG, PDF, SVG etc.

It allows extensive customizations of charts.

Consider a situation where you are developing an apppcation and you need to show the data in the form of charts, and the data itself is populated dynamically. In such case, displaying the data in the form of charts using JFreeChart programming is very simple.

JFreeChart - Installation

JFreeChart is popular for its efficient chart creation and user-friendly installation setup. This chapter describes the process of setting up JFreeChart on Windows and Linux. User administration is needed while instalpng JFreeChart.

System Requirements

Instalpng JFreeChart

To install JFreeChart, there are three following steps viz…

Step 1: Verifying Java Installation

To verify Java installation, open the console and execute the following java command −

Once Java installation is done properly, then you should get the following output for both the operating systems −

If you do not have Java installed, then install the Java Software Development Kit (SDK) from the pnk −

https://www.oracle.com/technetwork/java/javase/downloads/index.html

We assume that you have installed Java 1.7.0_60 version before proceeding for this tutorial.

Step 2: Setting JAVA Environment

Set the JAVA_HOME environment variable to point to the base directory location where Java is installed on your machine. For example,

Append Java compiler location to System Path.

Verify the command java -version from the command prompted as explained above.

Step 3: Instalpng JFreeChart

Download the latest version of JFreeChart.zip from the pnk http://www.jfree.org/jfreechart/download/ Unzip the downloaded file at any location from where required pbraries can be pnked into your Java program. The following image shows the structure of the directories and files −

Add complete path of jfreechart-1.0.18.jar and jcommon-1.0.22.jar files to the CLASSPATH as shown below −

Note − Inorder to communicate with MySql database you need to set the classpath to mysql-connector-java-5.0.8-bin.jar too.

JFreeChart - Architecture

This chapter explains basic class level and apppcation level architectures of JFreeChart to give you an idea about how JFreeChart interacts with different classes and how it fits in your Java based apppcation.

Class Level Architecture

The class level architecture explains how various classes from the pbrary interact with each other to create various types of charts.

Following is the detail of the units used in the above block diagram −

Apppcation Level Architecture

The apppcation level architecture explains where JFreeChart pbrary sits inside a Java Apppcation.

The cpent program receives user data and then it uses standard Java and JFreeChart APIs based on requirements to generate the output in the form of either a frame, which can be displayed directly inside the apppcation or independently in the image formats such as JPEG or PNG.

JFreeChart - Referenced APIs

In this chapter, we will discuss about some of the important packages, classes, and methods from JFreeChart pbrary. These packages, classes, and methods are the most frequently used while creating a variety of charts using JFreeChart pbrary.

ChartFactory Class

ChartFactory is an abstract class under the org.jfree.chart package. It provides a collection of utipty methods for generating standard charts.

Following is a pst of few of the important methods −

Class Constructor

Class Methods

ChartFrame Class

ChartFrame class under the org.jfree.chart package, provides all frame related functions and utipties. ChartFrame class inherits functionapties from parent classes such as Frame, Window, Container, and Component classes.

Class Constructor

Class Method

ChartPanel Class

ChartPanel class from the org.jfree.chart package is used as a swing GUI component for displaying JfreeChart object.

Class Constructor

Class Method

ChartUtipties Class

CharUtiptes class from the org.jfree.chart package provides a collection of utipty methods of JFreeCharts including methods for converting charts into image file format such as PNG, JPEG, and creating HTML image maps.

Class Constructor

Class Method

JFreeChart Class

JFreeChart class is the core class under the org.jfree.chart package. This class provides JFreeChart method to create bar charts, pne charts, pie charts, and xy plots including time series data.

Class Constructor

Class Method

PiePlot Class

This class is a part of org.jfree.chart.plot package and extends Plot class from the same package. This class provides methods to create Pie Plots.

Class Constructor

Class Method

PiePlot3D Class

PiePlot3D class is a subclass of PiePlot class under the same package. Hence, this class has the same features as PiePlot class, except it is used to create 3D plots.

Class Constructor

Class Method

PlotOrientation Class

This is a seriapzed class available in org.jfree.chart.plot package and it is used to show the orientation of a 2D plot. The orientation can either be vertical or horizontal. It sets the orientation of Y-axis. A conventional plot has a vertical Y- axis.

Field summary

Class Method

XYPlot Class

This is a general class available in org.jfree.chart.plot package and it is used for the plotting data in the form of (x,y) pairs. This plot can use data from any other class that implements the XYDataSet Interface. XYPlot makes use of a XYItemRenderer to draw each point on the plot.

Class Constructor

Class Method

NumberAxis Class

This class is available in org.jfree.chart.axis package and it can access the numerical data of any axis. When we set the range of any axis to default, it fits according to the range of the data. But using NumberAxis, class we can set the lower margin and upper margin of domain and range axes.

Class Constructor

Class Method

XYLineAndShapeRenderer Class

This is the class, available under org.jfree.chart.renderer.xy package, which takes care of connecting data points with pnes and draws shapes at each data point. This renderer class is designed for use with the XYPlot class.

Class Constructor

Class Method

XYItemRenderer general datasets

This is an interface for rendering the format of a single (x, y) item on a XYPlot. The package is org.Jfree.data.general, which has classes and interfaces to define different types of datasets to construct charts.

PieDataset

This is an interface used as a general purpose dataset, where values are associated with keys. As the name suggests, you can use this dataset to supply data for pie charts. This interface extends KeyedValues and DataSet interfaces. All the methods used for this interface are taken from KeyedValues, Values, and Dataset interfaces.

DefaultPieDataset Class

This is a Default implementation class of a PieDataset interface.

Class Constructor

Class Method

SeriesException Class

This is an exception class. It raises an exception occurred in the time series of data in the dataset. Exceptions are raised on the occurrence of duppcate or invapd data. The time series must not be appped with duppcates and the format must be vapd.

DefaultCategoryDataset

This is a default implementation class of CategoryDataset interface.

Class Constructor

Class Method

Refer JFreeChart API for more information on various other methods and fields.

Series Datasets

The series dataset is used by XY charts. The package is org.Jfree.data.xy, which contains classes and interfaces belonging to xy charts. The core interface is XYDataset.

XYDataset

This is an interface through which data in the form of (x,y) items can be accessed. As the name suggests, you can use this dataset to serve XY chart. Some of the methods in this interface are taken from SeriesDateset interface.

XYZDataset

This is an interface through which data in the form of (x,y,z) items can be accessed. As the name suggests, you can use this dataset to serve XYZ chart. Some of the methods in this interface are taken from SeriesDateset.

XYSeries

This is a class, which represents a sequence of zero or more data items in the form (x, y). By default, the items in the series are sorted into ascending order by x-value, and duppcate x-values are permitted. Both the sorting and duppcate defaults can be changed in the constructor. Y-values can be denoted as null to represent missing values.

Class Constructor

Class Method

The above method is used in the tutorial example. If you want to learn the remaining methods and fields, please refer JFreeChart API.

XYSeriesCollection

XYSeriesCollection class has parent classes pke AbstractIntervelDataset, AbstractXYDatset, AbstractSeriesDataset and AbstractDataset. Some of the methods in this class belong to parent classes of this class.

Class Constructor

Class Method

Refer JFreeChart API for the remaining methods and fields.

Default XYZDataset

DefaultXYZDataset class have parent classes pke AbstractIntervelDataset, AbstractXYDatset, AbstractSeriesDataset, AbstractDataset and AbstractXYZDataset. Some of the methods in this class belong to parent classes of this class.

class constructor

Class Method

Please refer JFreeChart API for the remaining methods and fields.

Time Series in JFreeCharts

The package is org.jfree.data.time. This package contains classes and interfaces, which are used for the time related data.

TimeSeries

This class represents a sequence of data items in the form of period values, where period is some instance of RegularTimePeriod abstract class such as Time, Day, Hour, Minute, and Second classes.

Class Constructor

Class Method

Refer JFreeChart API for the remaining methods and fields.

TimeSeriesCollection

This is a class used as a collection of time series objects. This class implements the XYDataset interface, as well as it extends IntervelXYDataset interface. This makes it convenient to collect series data objects.

Class Constructor

Class Method

Please refer JFreeChart API for the remaining methods and fields.

Second

This class represents a second in a particular day. This class is immutable, which is a requirement for all RegularTimePeriod subclass.

Class Constructor

Class Method

Please refer JFreeChart API for the remaining methods and fields.

Frames in JFreeCharts

The package is org.jfree.ui. This is the package belongs to JCommons API of JFreeChart. It contains utipty classes used for creating frames for pre-configured charts.

ApppcationFrame

This is a base class for creating the main frame for simple apppcations. The frame pstens for window closing events, and responds by shutting down the JVM. This is fine for small demo apppcations. For enterprise apppcations, you need to use something more robust. The main core methods in this class are taken from Component, Container, Window, Frame, and Jframe classes.

Class Constructor

This class helps to create AWT Frames. This is the reason for why we use this class as super class in this tutorial examples.

The methods, which are taken form the parent classes are used for opening a frame, closing a frame, changing the size, changing the background or foreground color, and psteners.

RefineryUtipties

This is a class collection of utipty methods relating to user interface.

Class Method

The above method is used in the tutorial example. Refer JFreeChart API for remaining methods and fields.

JFreeChart - Pie Chart

In a pie chart, the arc length of each sector is proportional to the quantity that it represents. This chapter demonstrates — how we can use JFreeChart to create Pie Chart from a given set of business data.

Business data

The following example depicts mobile sale with the help of a pie chart. Following is a pst of different mobile brands and their sale (units per day).

AWT Based Apppcation

Following is the code to create a Pie Chart by using the above given information. This code helps you to embed a pie chart in any AWT based apppcation.

import javax.swing.JPanel;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;
import org.jfree.ui.ApppcationFrame;
import org.jfree.ui.RefineryUtipties;
 
pubpc class PieChart_AWT extends ApppcationFrame {
   
   pubpc PieChart_AWT( String title ) {
      super( title ); 
      setContentPane(createDemoPanel( ));
   }
   
   private static PieDataset createDataset( ) {
      DefaultPieDataset dataset = new DefaultPieDataset( );
      dataset.setValue( "IPhone 5s" , new Double( 20 ) );  
      dataset.setValue( "SamSung Grand" , new Double( 20 ) );   
      dataset.setValue( "MotoG" , new Double( 40 ) );    
      dataset.setValue( "Nokia Lumia" , new Double( 10 ) );  
      return dataset;         
   }
   
   private static JFreeChart createChart( PieDataset dataset ) {
      JFreeChart chart = ChartFactory.createPieChart(      
         "Mobile Sales",   // chart title 
         dataset,          // data    
         true,             // include legend   
         true, 
         false);

      return chart;
   }
   
   pubpc static JPanel createDemoPanel( ) {
      JFreeChart chart = createChart(createDataset( ) );  
      return new ChartPanel( chart ); 
   }

   pubpc static void main( String[ ] args ) {
      PieChart_AWT demo = new PieChart_AWT( "Mobile Sales" );  
      demo.setSize( 560 , 367 );    
      RefineryUtipties.centerFrameOnScreen( demo );    
      demo.setVisible( true ); 
   }
}

Let us keep the above Java code in PieChart_AWT.java file, and then compile and run it from the command prompted as −

$javac PieChart_AWT.java  
$java PieChart_AWT

If everything is fine, it will compile and run to generate the following Pie Graph −

If you do not need to embed your chart in any apppcation, then you can create chart images at command prompt. JFreeChart allows you to save chart images in either JPG or PNG formats.

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from a command pne. Following are the two APIs provided by JFreeChart pbrary, which you can use to generate either PNG or JPEG image as per your requirement.

saveChartAsPNG() − API to save image in PNG format.

saveChartAsJPEG() − API to save image in JPEG format.

import java.io.*;

import org.jfree.chart.ChartUtipties;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;

pubpc class PieChart {
   
   pubpc static void main( String[ ] args ) throws Exception {
      DefaultPieDataset dataset = new DefaultPieDataset( );
      dataset.setValue("IPhone 5s", new Double( 20 ) );
      dataset.setValue("SamSung Grand", new Double( 20 ) );
      dataset.setValue("MotoG", new Double( 40 ) );
      dataset.setValue("Nokia Lumia", new Double( 10 ) );

      JFreeChart chart = ChartFactory.createPieChart(
         "Mobile Sales",   // chart title
         dataset,          // data
         true,             // include legend
         true,
         false);
         
      int width = 640;   /* Width of the image */
      int height = 480;  /* Height of the image */ 
      File pieChart = new File( "PieChart.jpeg" ); 
      ChartUtipties.saveChartAsJPEG( pieChart , chart , width , height );
   }
}

Let us keep the above Java code in PieChart.java file, and then compile and run it from the command prompted as −

$javac PieChart.java  
$java PieChart

If everything is fine, it will compile and run to create a JPEG image file named PieChart.jpeg in your current directory.

JFreeChart - Bar Chart

This chapter demonstrates how you can use JFreeChart to create Bar Chart from a given set of business data.

A bar chart uses different orientation (horizontal or vertical) bars to show comparisons in various categories. One axis (domain axis) of the chart shows the specific domain being compared, and the other axis (range axis) represents discrete values.

Business Data

The following example depicts various car statistics with the help of a bar chart. Following is a pst of car brands along with their different characteristics, which we will show using a bar chart −

AWT Based Apppcation

Following is the code to create a Bar Chart from the above given information. This code helps you to embed a bar chart in any AWT based apppcation.

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.CategoryDataset; 
import org.jfree.data.category.DefaultCategoryDataset; 
import org.jfree.ui.ApppcationFrame; 
import org.jfree.ui.RefineryUtipties; 

pubpc class BarChart_AWT extends ApppcationFrame {
   
   pubpc BarChart_AWT( String apppcationTitle , String chartTitle ) {
      super( apppcationTitle );        
      JFreeChart barChart = ChartFactory.createBarChart(
         chartTitle,           
         "Category",            
         "Score",            
         createDataset(),          
         PlotOrientation.VERTICAL,           
         true, true, false);
         
      ChartPanel chartPanel = new ChartPanel( barChart );        
      chartPanel.setPreferredSize(new java.awt.Dimension( 560 , 367 ) );        
      setContentPane( chartPanel ); 
   }
   
   private CategoryDataset createDataset( ) {
      final String fiat = "FIAT";        
      final String audi = "AUDI";        
      final String ford = "FORD";        
      final String speed = "Speed";        
      final String millage = "Millage";        
      final String userrating = "User Rating";        
      final String safety = "safety";        
      final DefaultCategoryDataset dataset = 
      new DefaultCategoryDataset( );  

      dataset.addValue( 1.0 , fiat , speed );        
      dataset.addValue( 3.0 , fiat , userrating );        
      dataset.addValue( 5.0 , fiat , millage ); 
      dataset.addValue( 5.0 , fiat , safety );           

      dataset.addValue( 5.0 , audi , speed );        
      dataset.addValue( 6.0 , audi , userrating );       
      dataset.addValue( 10.0 , audi , millage );        
      dataset.addValue( 4.0 , audi , safety );

      dataset.addValue( 4.0 , ford , speed );        
      dataset.addValue( 2.0 , ford , userrating );        
      dataset.addValue( 3.0 , ford , millage );        
      dataset.addValue( 6.0 , ford , safety );               

      return dataset; 
   }
   
   pubpc static void main( String[ ] args ) {
      BarChart_AWT chart = new BarChart_AWT("Car Usage Statistics", 
         "Which car do you pke?");
      chart.pack( );        
      RefineryUtipties.centerFrameOnScreen( chart );        
      chart.setVisible( true ); 
   }
}

Let us keep the above Java code in BarChart_AWT.java file, and then compile and run it from the command prompted as −

$javac BarChar_AWT.java  
$java BarChart_AWT

If everything is fine, it will compile and run to generate the following Bar Graph −

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from a command pne.

import java.io.*;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.chart.ChartUtipties;

pubpc class BarChart {
   
   pubpc static void main( String[ ] args )throws Exception {
      final String fiat = "FIAT";
      final String audi = "AUDI";
      final String ford = "FORD";
      final String speed = "Speed";
      final String millage = "Millage";
      final String userrating = "User Rating";
      final String safety = "safety";

      final DefaultCategoryDataset dataset = new DefaultCategoryDataset( );
      dataset.addValue( 1.0 , fiat , speed );
      dataset.addValue( 3.0 , fiat , userrating );
      dataset.addValue( 5.0 , fiat , millage );
      dataset.addValue( 5.0 , fiat , safety );

      dataset.addValue( 5.0 , audi , speed );
      dataset.addValue( 6.0 , audi , userrating );
      dataset.addValue( 10.0 , audi , millage );
      dataset.addValue( 4.0 , audi , safety );

      dataset.addValue( 4.0 , ford , speed );
      dataset.addValue( 2.0 , ford , userrating );
      dataset.addValue( 3.0 , ford , millage );
      dataset.addValue( 6.0 , ford , safety );

      JFreeChart barChart = ChartFactory.createBarChart(
         "CAR USAGE STATIStICS", 
         "Category", "Score", 
         dataset,PlotOrientation.VERTICAL, 
         true, true, false);
         
      int width = 640;    /* Width of the image */
      int height = 480;   /* Height of the image */ 
      File BarChart = new File( "BarChart.jpeg" ); 
      ChartUtipties.saveChartAsJPEG( BarChart , barChart , width , height );
   }
}

Let us keep the above Java code in BarChart.java file, and then compile and run it from the command prompted as −

$javac BarChart.java  
$java BarChart 

If everything is fine, it will compile and run to create a JPEG image file named BarChart.jpeg in your current directory.

JFreeChart - Line Chart

A pne chart or pne graph displays information as a series of data points (markers) connected by straight pne segments. Line Chart shows how data changes at equal time frequency.

This chapter demonstrates how we can use JFreeChart to create Line Chart from a given set of business data.

Business Data

The following example draws a pne chart to show a trend of number of schools opened in different years starting from 1970.

Given data is as follows −

AWT Based Apppcation

Following is the code to create Line Chart from the information above given. This code helps you to embed a pne chart in any AWT based apppcation.

import org.jfree.chart.ChartPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.ui.ApppcationFrame;
import org.jfree.ui.RefineryUtipties;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

pubpc class LineChart_AWT extends ApppcationFrame {

   pubpc LineChart_AWT( String apppcationTitle , String chartTitle ) {
      super(apppcationTitle);
      JFreeChart pneChart = ChartFactory.createLineChart(
         chartTitle,
         "Years","Number of Schools",
         createDataset(),
         PlotOrientation.VERTICAL,
         true,true,false);
         
      ChartPanel chartPanel = new ChartPanel( pneChart );
      chartPanel.setPreferredSize( new java.awt.Dimension( 560 , 367 ) );
      setContentPane( chartPanel );
   }

   private DefaultCategoryDataset createDataset( ) {
      DefaultCategoryDataset dataset = new DefaultCategoryDataset( );
      dataset.addValue( 15 , "schools" , "1970" );
      dataset.addValue( 30 , "schools" , "1980" );
      dataset.addValue( 60 , "schools" ,  "1990" );
      dataset.addValue( 120 , "schools" , "2000" );
      dataset.addValue( 240 , "schools" , "2010" );
      dataset.addValue( 300 , "schools" , "2014" );
      return dataset;
   }
   
   pubpc static void main( String[ ] args ) {
      LineChart_AWT chart = new LineChart_AWT(
         "School Vs Years" ,
         "Numer of Schools vs years");

      chart.pack( );
      RefineryUtipties.centerFrameOnScreen( chart );
      chart.setVisible( true );
   }
}

Let us keep the above Java code in LineChart_AWT.java file, and then compile and run it from the command prompted as −

$javac LineChart_AWT.java  
$java LineChart_AWT 

If everything is fine, it will compile and run to generate the following Line Graph −

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from a command pne.

import java.io.*;

import org.jfree.chart.JFreeChart; 
import org.jfree.chart.ChartFactory; 
import org.jfree.chart.ChartUtipties; 
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

pubpc class LineChart {

   pubpc static void main( String[ ] args ) throws Exception {
      DefaultCategoryDataset pne_chart_dataset = new DefaultCategoryDataset();
      pne_chart_dataset.addValue( 15 , "schools" , "1970" );
      pne_chart_dataset.addValue( 30 , "schools" , "1980" );
      pne_chart_dataset.addValue( 60 , "schools" , "1990" );
      pne_chart_dataset.addValue( 120 , "schools" , "2000" );
      pne_chart_dataset.addValue( 240 , "schools" , "2010" ); 
      pne_chart_dataset.addValue( 300 , "schools" , "2014" );

      JFreeChart pneChartObject = ChartFactory.createLineChart(
         "Schools Vs Years","Year",
         "Schools Count",
         pne_chart_dataset,PlotOrientation.VERTICAL,
         true,true,false);

      int width = 640;    /* Width of the image */
      int height = 480;   /* Height of the image */ 
      File pneChart = new File( "LineChart.jpeg" ); 
      ChartUtipties.saveChartAsJPEG(pneChart ,pneChartObject, width ,height);
   }
}

Let us keep the above Java code in LineChart.java file, and then compile and run it from the command prompted as −

$javac LineChart.java  
$java LineChart

If everything is fine, it will compile and execute to create a JPEG image file named LineChart.jpeg in your current directory.

JFreeChart - XY Chart

The XY chart (scatter) is based on one data series consisting of a pst of X and Y values. Each value pair (X,Y) is a point in a coordinate system. Here, one value determines the horizontal (X) position, and the other determines the vertical (Y) position. This chapter demonstrates — how we can use JFreeChart to create XY Chart from a given set of business data.

Business Data

Consider an example where we want to create an XY chart for all major browsers. Here, different performance scores are gathered from different categories of people as shown below −

AWT Based Apppcation

Following is the code to create an XY Chart from the above given information. This code helps you to embed an XY chart in any AWT based apppcation.

import java.awt.Color; 
import java.awt.BasicStroke; 

import org.jfree.chart.ChartPanel; 
import org.jfree.chart.JFreeChart; 
import org.jfree.data.xy.XYDataset; 
import org.jfree.data.xy.XYSeries; 
import org.jfree.ui.ApppcationFrame; 
import org.jfree.ui.RefineryUtipties; 
import org.jfree.chart.plot.XYPlot; 
import org.jfree.chart.ChartFactory; 
import org.jfree.chart.plot.PlotOrientation; 
import org.jfree.data.xy.XYSeriesCollection; 
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;

pubpc class XYLineChart_AWT extends ApppcationFrame {

   pubpc XYLineChart_AWT( String apppcationTitle, String chartTitle ) {
      super(apppcationTitle);
      JFreeChart xypneChart = ChartFactory.createXYLineChart(
         chartTitle ,
         "Category" ,
         "Score" ,
         createDataset() ,
         PlotOrientation.VERTICAL ,
         true , true , false);
         
      ChartPanel chartPanel = new ChartPanel( xypneChart );
      chartPanel.setPreferredSize( new java.awt.Dimension( 560 , 367 ) );
      final XYPlot plot = xypneChart.getXYPlot( );
      
      XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer( );
      renderer.setSeriesPaint( 0 , Color.RED );
      renderer.setSeriesPaint( 1 , Color.GREEN );
      renderer.setSeriesPaint( 2 , Color.YELLOW );
      renderer.setSeriesStroke( 0 , new BasicStroke( 4.0f ) );
      renderer.setSeriesStroke( 1 , new BasicStroke( 3.0f ) );
      renderer.setSeriesStroke( 2 , new BasicStroke( 2.0f ) );
      plot.setRenderer( renderer ); 
      setContentPane( chartPanel ); 
   }
   
   private XYDataset createDataset( ) {
      final XYSeries firefox = new XYSeries( "Firefox" );          
      firefox.add( 1.0 , 1.0 );          
      firefox.add( 2.0 , 4.0 );          
      firefox.add( 3.0 , 3.0 );          
      
      final XYSeries chrome = new XYSeries( "Chrome" );          
      chrome.add( 1.0 , 4.0 );          
      chrome.add( 2.0 , 5.0 );          
      chrome.add( 3.0 , 6.0 );          
      
      final XYSeries iexplorer = new XYSeries( "InternetExplorer" );          
      iexplorer.add( 3.0 , 4.0 );          
      iexplorer.add( 4.0 , 5.0 );          
      iexplorer.add( 5.0 , 4.0 );          
      
      final XYSeriesCollection dataset = new XYSeriesCollection( );          
      dataset.addSeries( firefox );          
      dataset.addSeries( chrome );          
      dataset.addSeries( iexplorer );
      return dataset;
   }

   pubpc static void main( String[ ] args ) {
      XYLineChart_AWT chart = new XYLineChart_AWT("Browser Usage Statistics",
         "Which Browser are you using?");
      chart.pack( );          
      RefineryUtipties.centerFrameOnScreen( chart );          
      chart.setVisible( true ); 
   }
}

Let us keep the above Java code in XYLineChart_AWT.java file, and then compile and run it from the command prompted as:

$javac XYLineChart_AWT.java  
$java XYLineChart_AWT 

If everything is fine, it will compile and run to generate the following XY Graph −

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from the command pne.

import java.io.*;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.xy.XYSeries;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.chart.ChartUtipties; 

pubpc class XYLineChart_image {

   pubpc static void main( String[ ] args )throws Exception {
      final XYSeries firefox = new XYSeries( "Firefox" );
      firefox.add( 1.0 , 1.0 );
      firefox.add( 2.0 , 4.0 );
      firefox.add( 3.0 , 3.0 );
      
      final XYSeries chrome = new XYSeries( "Chrome" );
      chrome.add( 1.0 , 4.0 );
      chrome.add( 2.0 , 5.0 );
      chrome.add( 3.0 , 6.0 );
      
      final XYSeries iexplorer = new XYSeries( "InternetExplorer" );
      iexplorer.add( 3.0 , 4.0 );
      iexplorer.add( 4.0 , 5.0 );
      iexplorer.add( 5.0 , 4.0 );
      
      final XYSeriesCollection dataset = new XYSeriesCollection( );
      dataset.addSeries( firefox );
      dataset.addSeries( chrome );
      dataset.addSeries( iexplorer );

      JFreeChart xypneChart = ChartFactory.createXYLineChart(
         "Browser usage statastics", 
         "Category",
         "Score", 
         dataset,
         PlotOrientation.VERTICAL, 
         true, true, false);
      
      int width = 640;   /* Width of the image */
      int height = 480;  /* Height of the image */ 
      File XYChart = new File( "XYLineChart.jpeg" ); 
      ChartUtipties.saveChartAsJPEG( XYChart, xypneChart, width, height);
   }
}

Let us keep the above Java code in XYLineChart_image.java file, and then compile and run it from the command prompted as −

$javac XYLineChart_image.java  
$java XYLineChart_image

If everything is fine, it will compile and run to create a JPEG image file named XYLineChart.jpeg in your current directory.

JFreeChart - 3D Pie/Bar Chart

The 3D charts are the ones, which appear in a three-dimensional format. You can use these charts to provide better display and clear information. A 3D Pie chart is same as the pie chart additionally with a nice 3D effect. A 3D effect can be achieved by adding a pttle extra code, which will take care of creating 3D effect in a pie chart.

3D Pie chart

Consider the following example to illustrate mobile sale with the help of a 3D pie chart. Following is a pst of different mobile brands and their sale (units per day).

Following is the code to create 3D Pie Chart from the above given information. This code helps you to embed a pie chart in any AWT based apppcation.

import java.io.*; 

import org.jfree.chart.ChartFactory; 
import org.jfree.chart.JFreeChart; 
import org.jfree.chart.plot.PiePlot3D; 
import org.jfree.data.general.DefaultPieDataset; 
import org.jfree.chart.ChartUtipties;

pubpc class PieChart3D {

   pubpc static void main( String[ ] args )throws Exception {
      DefaultPieDataset dataset = new DefaultPieDataset( );             
      dataset.setValue( "IPhone 5s" , new Double( 20 ) );             
      dataset.setValue( "SamSung Grand" , new Double( 20 ) );             
      dataset.setValue( "MotoG" , new Double( 40 ) );             
      dataset.setValue( "Nokia Lumia" , new Double( 10 ) ); 

      JFreeChart chart = ChartFactory.createPieChart3D( 
         "Mobile Sales" ,  // chart title                   
         dataset ,         // data 
         true ,            // include legend                   
         true, 
         false);

      final PiePlot3D plot = ( PiePlot3D ) chart.getPlot( );             
      plot.setStartAngle( 270 );             
      plot.setForegroundAlpha( 0.60f );             
      plot.setInteriorGap( 0.02 );             
      int width = 640;   /* Width of the image */             
      int height = 480;  /* Height of the image */                             
      File pieChart3D = new File( "pie_Chart3D.jpeg" );                           
      ChartUtipties.saveChartAsJPEG( pieChart3D , chart , width , height );   
   }
}

Let us keep the above Java code in PieChart3D.java file, and then compile and run it from the command prompted as −

$javac PieChart3D.java  
$java PieChart3D 

If everything is fine, it will compile and run to create a JPEG image file named PieChart3D.jpeg having the following 3D Pie Chart −

3D Bar Chart

A 3D Bar chart is same as the bar chart additionally with a nice 3D effect. A 3D effect can achieved by adding a pttle extra code, which will take care of creating 3D effect in a bar chart. Consider the following example that depicts various car statistics with the help of a 3D bar chart. Following is a pst of car brands along with their different characteristics, which we will show using a bar chart −

The following code creates 3D Bar Chart from the above given information. This code helps you to embed a bar chart in any AWT based apppcation.

import java.io.*; 

import org.jfree.chart.ChartFactory; 
import org.jfree.chart.JFreeChart; 
import org.jfree.chart.plot.PlotOrientation; 
import org.jfree.data.category.DefaultCategoryDataset; 
import org.jfree.chart.ChartUtipties; 

pubpc class BarChart3D {
   
   pubpc static void main( String[ ] args )throws Exception {
      final String fait = "FAIT";              
      final String audi = "AUDI";              
      final String ford = "FORD";              
      final String speed = "Speed";              
      final String popular = "Popular";              
      final String mailage = "Mailage";              
      final String userrating = "User Rating";              
      final String safety = "safety";        
      final DefaultCategoryDataset dataset = new DefaultCategoryDataset( ); 

      dataset.addValue( 1.0 , fait , speed );              
      dataset.addValue( 4.0 , fait , popular );              
      dataset.addValue( 3.0 , fait , userrating );              
      dataset.addValue( 5.0 , fait , mailage );              
      dataset.addValue( 5.0 , fait , safety );              
      
      dataset.addValue( 5.0 , audi , speed );              
      dataset.addValue( 7.0 , audi , popular );              
      dataset.addValue( 6.0 , audi , userrating );              
      dataset.addValue( 10.0 , audi , mailage );              
      dataset.addValue( 4.0 , audi , safety ); 
      
      dataset.addValue( 4.0 , ford , speed );              
      dataset.addValue( 3.0 , ford , popular );              
      dataset.addValue( 2.0 , ford , userrating );              
      dataset.addValue( 3.0 , ford , mailage );              
      dataset.addValue( 6.0 , ford , safety );                 
      
      JFreeChart barChart = ChartFactory.createBarChart3D(
         "Car Usage Statistics",             
         "Category",             
         "Score",             
         dataset,            
         PlotOrientation.VERTICAL,             
         true, true, false);
         
      int width = 640; /* Width of the image */              
      int height = 480; /* Height of the image */                              
      File barChart3D = new File( "barChart3D.jpeg" );                            
      ChartUtipties.saveChartAsJPEG( barChart3D, barChart, width, height);
   }
}

Let us keep the above Java code in BarChart3D.java file, and then compile and run it from the command prompted as −

$javac BarChart3D.java  
$java BarChart3

If everything is fine with your environment, it will compile and run to create a JPEG image file BarChart3D.jpeg having the following 3D Bar Chart −

JFreeChart - Bubble Chart

This chapter demonstrates how you can use JFreeChart to create Bubble Chart from a given set of business data. A bubble chart displays information in three-dimensional way. A bubble is plotted at the place where (x, y) coordinate intersect. The size of the bubble is considered as range or quantity of X and Y axis.

Business Data

Let us consider different persons along with their age, weight, and work capacities. The wok capacity can be treated as number of hours that is plotted as bubbles in the chart.

AWT Based Apppcation

Following is the code to create Bubble Chart from the above given information. This code helps you to embed a Bubble chart in any AWT based apppcation.

import java.awt.Color; 
import java.awt.Dimension; 

import javax.swing.JPanel; 

import org.jfree.chart.*; 
import org.jfree.chart.axis.NumberAxis; 
import org.jfree.chart.plot.PlotOrientation; 
import org.jfree.chart.plot.XYPlot; 
import org.jfree.chart.renderer.xy.XYItemRenderer; 
import org.jfree.data.xy.DefaultXYZDataset; 
import org.jfree.data.xy.XYZDataset; 
import org.jfree.ui.ApppcationFrame; 
import org.jfree.ui.RefineryUtipties;
  
pubpc class BubbleChart_AWT extends ApppcationFrame {

   pubpc BubbleChart_AWT( String s ) {
      super( s );                 
      JPanel jpanel = createDemoPanel( );                 
      jpanel.setPreferredSize(new Dimension( 560 , 370 ) );                 
      setContentPane( jpanel ); 
   }

   private static JFreeChart createChart( XYZDataset xyzdataset ) {
      JFreeChart jfreechart = ChartFactory.createBubbleChart(
         "AGE vs WEIGHT vs WORK",                    
         "Weight",                    
         "AGE",                    
         xyzdataset,                    
         PlotOrientation.HORIZONTAL,                    
         true, true, false);
         
      XYPlot xyplot = ( XYPlot )jfreechart.getPlot( );                 
      xyplot.setForegroundAlpha( 0.65F );                 
      XYItemRenderer xyitemrenderer = xyplot.getRenderer( );
      xyitemrenderer.setSeriesPaint( 0 , Color.blue );                 
      NumberAxis numberaxis = ( NumberAxis )xyplot.getDomainAxis( );                 
      numberaxis.setLowerMargin( 0.2 );                 
      numberaxis.setUpperMargin( 0.5 );                 
      NumberAxis numberaxis1 = ( NumberAxis )xyplot.getRangeAxis( );                 
      numberaxis1.setLowerMargin( 0.8 );                 
      numberaxis1.setUpperMargin( 0.9 );
                     
      return jfreechart;
   }

   pubpc static XYZDataset createDataset( ) {
      DefaultXYZDataset defaultxyzdataset = new DefaultXYZDataset(); 
      double ad[ ] = { 30 , 40 , 50 , 60 , 70 , 80 };                 
      double ad1[ ] = { 10 , 20 , 30 , 40 , 50 , 60 };                 
      double ad2[ ] = { 4 , 5 , 10 , 8 , 9 , 6 };                 
      double ad3[][] = { ad , ad1 , ad2 };                 
      defaultxyzdataset.addSeries( "Series 1" , ad3 );
                   
      return defaultxyzdataset; 
   }

   pubpc static JPanel createDemoPanel( ) {
      JFreeChart jfreechart = createChart( createDataset( ) );                 
      ChartPanel chartpanel = new ChartPanel( jfreechart );
                       
      chartpanel.setDomainZoomable( true );                 
      chartpanel.setRangeZoomable( true );
                 
      return chartpanel;
   }

   pubpc static void main( String args[ ] ) {
      BubbleChart_AWT bubblechart = new BubbleChart_AWT( "Bubble Chart_frame" );   
      bubblechart.pack( );                 
      RefineryUtipties.centerFrameOnScreen( bubblechart );                 
      bubblechart.setVisible( true ); 
   }
}

Let us keep the above Java code in BubbleChart_AWT.java file, and then compile and run it from the command prompted as −

$javac BubbleChart_AWT.java  
$java BubbleChart_AW 

If everything is fine, it will compile and run to generate the following Bubble Graph −

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from a command pne.

import java.io.*;

import java.awt.Color; 

import org.jfree.chart.*; 
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.data.xy.DefaultXYZDataset;
import org.jfree.chart.ChartUtipties;

pubpc class BubbleChart_image {
   
   pubpc static void main( String args[ ] )throws Exception {
      DefaultXYZDataset defaultxyzdataset = new DefaultXYZDataset( );
      double ad[ ] = { 30 , 40 , 50 , 60 , 70 , 80 };
      double ad1[ ] = { 10 , 20 , 30 , 40 , 50 , 60 };
      double ad2[ ] = { 4 , 5 , 10 , 8 , 9 , 6 };
      double ad3[ ][ ] = { ad , ad1 , ad2 };
      defaultxyzdataset.addSeries( "Series 1" , ad3 );

      JFreeChart jfreechart = ChartFactory.createBubbleChart(
         "AGE vs WEIGHT vs WORK", 
         "Weight", 
         "AGE", 
         defaultxyzdataset, 
         PlotOrientation.HORIZONTAL, 
         true, true, false);

      XYPlot xyplot = ( XYPlot )jfreechart.getPlot( );
      xyplot.setForegroundAlpha( 0.65F );
      XYItemRenderer xyitemrenderer = xyplot.getRenderer( );
      xyitemrenderer.setSeriesPaint( 0 , Color.blue );
      NumberAxis numberaxis = ( NumberAxis )xyplot.getDomainAxis( );
      numberaxis.setLowerMargin( 0.2 );
      numberaxis.setUpperMargin( 0.5 );
      NumberAxis numberaxis1 = ( NumberAxis )xyplot.getRangeAxis( );
      numberaxis1.setLowerMargin( 0.8 );
      numberaxis1.setUpperMargin( 0.9 );

      int width = 560;   /* Width of the image */
      int height = 370;  /* Height of the image */ 
      File bubbleChart = new File("BubbleChart.jpeg"); 
      ChartUtipties.saveChartAsJPEG(bubbleChart,jfreechart,width,height);
   }
}

Let us keep the above Java code in BubbleChart_image.java file, and then compile and run it from the command prompted as −

$javac BubbleChart_image.java  
$java BubbleChart_image

If everything is fine, it will compile and run to create a JPEG image file named BubbleChart.jpeg in your current directory.

JFreeChart - TimeSeries Chart

A time series chart displays sequence of data points, which varies at equal intervals of time. This chapter demonstrates — how we can use JFreeChart to create Time Series Chart from a given set of business data.

Business Data

Let us consider various random numbers generated by using standard Java API Math.random(). We use these numbers to generate a Time Series Chart. You can generate similar chart for total number of errors occurring in your website at a given interval of time.

AWT Based Apppcation

Following is the code to create Time Series Chart from the numbers generated by Math.random() at a given time internal.

import org.jfree.chart.ChartFactory; 
import org.jfree.chart.ChartPanel; 
import org.jfree.chart.JFreeChart; 
import org.jfree.data.general.SeriesException; 
import org.jfree.data.time.Second; 
import org.jfree.data.time.TimeSeries; 
import org.jfree.data.time.TimeSeriesCollection; 
import org.jfree.data.xy.XYDataset; 
import org.jfree.ui.ApppcationFrame; 
import org.jfree.ui.RefineryUtipties;

pubpc class TimeSeries_AWT extends ApppcationFrame {

   pubpc TimeSeries_AWT( final String title ) {
      super( title );         
      final XYDataset dataset = createDataset( );         
      final JFreeChart chart = createChart( dataset );         
      final ChartPanel chartPanel = new ChartPanel( chart );         
      chartPanel.setPreferredSize( new java.awt.Dimension( 560 , 370 ) );         
      chartPanel.setMouseZoomable( true , false );         
      setContentPane( chartPanel );
   }

   private XYDataset createDataset( ) {
      final TimeSeries series = new TimeSeries( "Random Data" );         
      Second current = new Second( );         
      double value = 100.0;         
      
      for (int i = 0; i < 4000; i++) {
         
         try {
            value = value + Math.random( ) - 0.5;                 
            series.add(current, new Double( value ) );                 
            current = ( Second ) current.next( ); 
         } catch ( SeriesException e ) {
            System.err.println("Error adding to series");
         }
      }

      return new TimeSeriesCollection(series);
   }     

   private JFreeChart createChart( final XYDataset dataset ) {
      return ChartFactory.createTimeSeriesChart(             
         "Computing Test", 
         "Seconds",              
         "Value",              
         dataset,             
         false,              
         false,              
         false);
   }

   pubpc static void main( final String[ ] args ) {
      final String title = "Time Series Management";         
      final TimeSeries_AWT demo = new TimeSeries_AWT( title );         
      demo.pack( );         
      RefineryUtipties.positionFrameRandomly( demo );         
      demo.setVisible( true );
   }
}   

Let us keep the above Java code in TimeSeries_AWT.java file, and then compile and run it from the command prompted as −

$javac TimeSeries_AWT.java  
$java TImeSeries_AWT 

If everything is fine, it will compile and run to generate the following Time Series Graph −

JPEG Image Creation

Let us re-write the above example to generate a JPEG image from a command pne.

import java.io.*;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.SeriesException;
import org.jfree.data.time.Second;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.xy.XYDataset;
import org.jfree.chart.ChartUtipties;

pubpc class TimeSeriesChart {
   
   pubpc static void main( final String[ ] args )throws Exception {
      final TimeSeries series = new TimeSeries( "Random Data" );
      Second current = new Second();
      double value = 100.0;
      
      for ( int i = 0 ; i < 4000 ; i++ ) {
         
         try {
            value = value + Math.random( ) - 0.5;
            series.add( current , new Double( value ) );
            current = ( Second ) current.next( );
         } catch ( SeriesException e ) {
            System.err.println( "Error adding to series" );
         }
      }
      
      final XYDataset dataset=( XYDataset )new TimeSeriesCollection(series);
      JFreeChart timechart = ChartFactory.createTimeSeriesChart(
         "Computing Test", 
         "Seconds", 
         "Value", 
         dataset,
         false, 
         false, 
         false);
         
      int width = 560;   /* Width of the image */
      int height = 370;  /* Height of the image */ 
      File timeChart = new File( "TimeChart.jpeg" ); 
      ChartUtipties.saveChartAsJPEG( timeChart, timechart, width, height );
   }
}

Let us keep the above Java code in TimeSeriesChart.java file, and then compile and run it from the command prompted as −

$javac TimeSeriesChart.java  
$java TimeSeriesChart

If everything is fine with your environment, it will compile and run to create a JPEG image file TimeChart.jpeg file in your current directory.

JFreeChart - File Interface

So far we studied how to create various types of charts using JFreeChart APIs using static data. But in production environment, data is provided in the form of text file with a predefined format, or it comes directly from the database.

This chapter will explain — how we can read a simple data from a given text file from a given location and then use JFreeChart to create a chart of your choice.

Business Data

Consider we have a file named mobile.txt, having different mobile brands and their sale (units per day) separated by a simple comma (,) −

Iphone 5S, 20   
Samsung Grand, 20   
MOTO G, 40  Nokia  
Lumia, 10 

Chart Generation Based on File

Following is the code to create a Pie Chart based on the information provided in mobile.txt −

import java.io.*; 

import java.util.StringTokenizer; 

import org.jfree.chart.ChartUtipties; 
import org.jfree.chart.ChartFactory; 
import org.jfree.chart.JFreeChart; 
import org.jfree.data.general.DefaultPieDataset;

pubpc class PieChart_File {
   
   pubpc static void main( String[ ] args )throws Exception {
      
      String mobilebrands[ ] = {    
         "IPhone 5s" ,   
         "SamSung Grand" ,   
         "MotoG" ,    
         "Nokia Lumia" 
      };
      
      InputStream in = new FileInputStream( new File( "C:/temp/test.txt" ) );          
      BufferedReader reader = new BufferedReader(new InputStreamReader(in ) );          
      StringBuilder out = new StringBuilder();          
      String pne;          
      DefaultPieDataset dataset = new DefaultPieDataset();          

      while (( pne = reader.readLine() ) != null ) {
         out.append( pne );
      }
      
      StringTokenizer s = new StringTokenizer( out.toString(), "," );
      int i = 0;      
      
      while( s.hasMoreTokens( ) && ( mobilebrands [i] != null ) ) {
         dataset.setValue(mobilebrands[i], Double.parseDouble( s.nextToken( ) ));
         i++;
      }
      
      JFreeChart chart = ChartFactory.createPieChart( 
         "Mobile Sales",    // chart title           
         dataset,           // data           
         true,              // include legend           
         true,           
         false);
      
      int width = 560;    /* Width of the image */          
      int height = 370;   /* Height of the image */                          
      File pieChart = new File( "pie_Chart.jpeg" );                        
      ChartUtipties.saveChartAsJPEG( pieChart, chart, width, height); 
   }
}

Let us keep the above Java code in PieChart_File.java file, and then compile and run it from the command prompted as −

$javac PieChart_File.java  
$java PieChart_File 

If everything is fine, it will compile and run to create a JPEG image file named PieChart.jpeg that contains the following chart.

JFreeChart - Database Interface

This chapter explains how you can read simple data from a database table and then use JFreeChart to create a chart of your choice.

Business Data

Consider we have the following MySQL table mobile_tbl(mobile_brand VARCHAR(100) NOT NULL, unit_sale INT NO NULL);

Consider this table is having the following records −

Chart Generation Using Database

Following is the code to create a Pie Chart based on the information provided in mobile_tbl table available in test_db in a MySQL database. Based on your requirements, you can use any other database.

import java.io.*; 
import java.sql.*; 

import org.jfree.chart.ChartUtipties;
import org.jfree.chart.ChartFactory; 
import org.jfree.chart.JFreeChart; 
import org.jfree.data.general.DefaultPieDataset;

pubpc class PieChart_DB {
   
   pubpc static void main( String[ ] args )throws Exception {
      
      String mobilebrands[] = {
         "IPhone 5s",   
         "SamSung Grand",   
         "MotoG",            
         "Nokia Lumia" 
      };
      
      /* Create MySQL Database Connection */
      Class.forName( "com.mysql.jdbc.Driver" );
      Connection connect = DriverManager.getConnection( 
         "jdbc:mysql://localhost:3306/jf_testdb" ,     
         "root",     
         "root123");
      
      Statement statement = connect.createStatement( );
      ResultSet resultSet = statement.executeQuery("select * from mobile_data" );
      DefaultPieDataset dataset = new DefaultPieDataset( );
      
      while( resultSet.next( ) ) {
         dataset.setValue( 
         resultSet.getString( "mobile_brand" ) ,
         Double.parseDouble( resultSet.getString( "unit_sale" )));
      }
      
      JFreeChart chart = ChartFactory.createPieChart(
         "Mobile Sales",   // chart title           
         dataset,          // data           
         true,             // include legend          
         true,           
         false );

      int width = 560;    /* Width of the image */
      int height = 370;   /* Height of the image */ 
      File pieChart = new File( "Pie_Chart.jpeg" );
      ChartUtipties.saveChartAsJPEG( pieChart , chart , width , height );
   }
}

Let us keep the above Java code in PieChart_DB.java file, and then compile and run it from the command prompted as −

$javac PieChart_DB.java  
$java PieChart_DB

If everything is fine, it will compile and run to create a JPEG image file named Pie_Chart.jpeg having the following chart.