Home » Desktop Java » JFreeChart » Jfree Candlestick Chart Example

About Ashraf Sarhan

Ashraf Sarhan is a passionate software engineer, an open source enthusiast, has a Bsc. degree in Computer and Information Systems from Alexandria University. He is experienced in building large, scalable and distributed enterprise applications/service in multiple domains. He also has a keen interest in JavaEE, SOA, Agile and Big Data technologies.

Jfree Candlestick Chart Example

Through this article, we are going to show you how to create a stock Candlestick chart using JFreeChart, JFreeChart is a free open source Java library for generating charts, it includes a wide range of charts such as pie charts, bar charts, line charts, scatter plots, time series charts (including moving averages, high-low-open-close charts and candlestick plots), Gantt charts, meter charts (dial and thermometer), combination charts and more.

Also, this example will demonstrate the combined charts facility of JFreeChart, it provides a flexible mechanism for combining multiple plots on a single chart. A combined XY plot is a plot that has two or more subplots sharing either the horizontal or the vertical axis.

To demonstrate, we will create a candlestick combined with volume chart. This is a common type of chart used in the finance industry. It is used to plot the (High, Low, Open, Close) prices of specific stock, along with the stock’s trading volume (the number of units traded) based on intraday financial market trades.

1. Project Environment

  1. JfreeChart 1.0.13
  2. Apache Maven 3.0.5
  3. JDK 1.8
  4. Eclipse 4.4 (Luna)

2. Project Structure

We create a simple Java Maven project with the following structure.


Figure 1: Project Structure

3. Dependencies

We have the following dependencies inside our below POM file.


<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">


		<!-- Generic properties -->



4. Constructing the Jfree Candlestick Chart

To create a Jfree combined chart, you should create the below components:

  1. Candlestick subplot
  2. Volume subplot
  3. Chart main plot to combine candlestick and volume subplots
  4. JFreeChart with previously created main plot

We have used the OHLCSeriesCollection class to represent both the Candlestick dataset. However, we used the TimeSeriesCollection class to represent the volume dataset. These datasets will be updated using the method addCandel(long time, double o, double h, double l, double c, long v) of JfreeCandlestickChart.java class.

Notice how each of the subplots has a null domain axis, since they share the parent plot’s axis.

Also, the combined plot is created with a VERTICAL orientation, which means that the sub-plots are stacked from top to bottom. You can control the amount of space allocated to each plot by specifying a weight for each plot as you add them to the parent plot where each plot is allocated space based on its weight as a percentage of the total.

In our example, the first subplot is allocated 3/4 of the space, and the second subplot is allocated 1/4 of the space.


package com.fx.jfree.chart.candlestick;

import java.awt.BorderLayout;
import java.awt.Color;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import javax.swing.JPanel;

import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.labels.StandardXYToolTipGenerator;
import org.jfree.chart.plot.CombinedDomainXYPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.CandlestickRenderer;
import org.jfree.chart.renderer.xy.XYBarRenderer;
import org.jfree.data.time.FixedMillisecond;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.time.ohlc.OHLCSeries;
import org.jfree.data.time.ohlc.OHLCSeriesCollection;

import com.fx.jfree.chart.model.Trade;
import com.fx.jfree.chart.utils.MathUtils;
import com.fx.jfree.chart.utils.TimeUtils;

 * The Class JfreeCandlestickChart.
 * @author ashraf
public class JfreeCandlestickChart extends JPanel {

	private static final DateFormat READABLE_TIME_FORMAT = new SimpleDateFormat("kk:mm:ss");

	private OHLCSeries ohlcSeries;
	private TimeSeries volumeSeries;

	private static final int MIN = 60000;
	// Every minute
	private int timeInterval = 1;
	private Trade candelChartIntervalFirstPrint = null;
	private double open = 0.0;
	private double close = 0.0;
	private double low = 0.0;
	private double high = 0.0;
	private long volume = 0;

	public JfreeCandlestickChart(String title) {
		// Create new chart
		final JFreeChart candlestickChart = createChart(title);
		// Create new chart panel
		final ChartPanel chartPanel = new ChartPanel(candlestickChart);
		chartPanel.setPreferredSize(new java.awt.Dimension(1200, 500));
		// Enable zooming
		add(chartPanel, BorderLayout.CENTER);

	private JFreeChart createChart(String chartTitle) {

		 * Creating candlestick subplot
		// Create OHLCSeriesCollection as a price dataset for candlestick chart
		OHLCSeriesCollection candlestickDataset = new OHLCSeriesCollection();
		ohlcSeries = new OHLCSeries("Price");
		// Create candlestick chart priceAxis
		NumberAxis priceAxis = new NumberAxis("Price");
		// Create candlestick chart renderer
		CandlestickRenderer candlestickRenderer = new CandlestickRenderer(CandlestickRenderer.WIDTHMETHOD_AVERAGE,
				false, new CustomHighLowItemLabelGenerator(new SimpleDateFormat("kk:mm"), new DecimalFormat("0.000")));
		// Create candlestickSubplot
		XYPlot candlestickSubplot = new XYPlot(candlestickDataset, null, priceAxis, candlestickRenderer);

		 * Creating volume subplot
		// creates TimeSeriesCollection as a volume dataset for volume chart
		TimeSeriesCollection volumeDataset = new TimeSeriesCollection();
		volumeSeries = new TimeSeries("Volume");
		// Create volume chart volumeAxis
		NumberAxis volumeAxis = new NumberAxis("Volume");
		// Set to no decimal
		volumeAxis.setNumberFormatOverride(new DecimalFormat("0"));
		// Create volume chart renderer
		XYBarRenderer timeRenderer = new XYBarRenderer();
		timeRenderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator("Volume--> Time={1} Size={2}",
				new SimpleDateFormat("kk:mm"), new DecimalFormat("0")));
		// Create volumeSubplot
		XYPlot volumeSubplot = new XYPlot(volumeDataset, null, volumeAxis, timeRenderer);

		 * Create chart main plot with two subplots (candlestickSubplot,
		 * volumeSubplot) and one common dateAxis
		// Creating charts common dateAxis
		DateAxis dateAxis = new DateAxis("Time");
		dateAxis.setDateFormatOverride(new SimpleDateFormat("kk:mm"));
		// reduce the default left/right margin from 0.05 to 0.02
		// Create mainPlot
		CombinedDomainXYPlot mainPlot = new CombinedDomainXYPlot(dateAxis);
		mainPlot.add(candlestickSubplot, 3);
		mainPlot.add(volumeSubplot, 1);

		JFreeChart chart = new JFreeChart(chartTitle, JFreeChart.DEFAULT_TITLE_FONT, mainPlot, true);
		return chart;

	 * Fill series with data.
	 * @param t the t
	public void addCandel(long time, double o, double h, double l, double c, long v) {
		try {
			// Add bar to the data. Let's repeat the same bar
			FixedMillisecond t = new FixedMillisecond(
			ohlcSeries.add(t, o, h, l, c);
			volumeSeries.add(t, v);
		} catch (ParseException e) {

	 * Aggregate the (open, high, low, close, volume) based on the predefined time interval (1 minute)
	 * @param t the t
	public void onTrade(Trade t) {
		double price = t.getPrice();
		if (candelChartIntervalFirstPrint != null) {
			long time = t.getTime();
			if (timeInterval == (int) ((time / MIN) - (candelChartIntervalFirstPrint.getTime() / MIN))) {
				// Set the period close price
				close = MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT);
				// Add new candle
				addCandel(time, open, high, low, close, volume);
				// Reset the intervalFirstPrint to null
				candelChartIntervalFirstPrint = null;
			} else {
				// Set the current low price
				if (MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT)  high)
					high = MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT);

				volume += t.getSize();
		} else {
			// Set intervalFirstPrint
			candelChartIntervalFirstPrint = t;
			// the first trade price in the day (day open price)
			open = MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT);
			// the interval low
			low = MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT);
			// the interval high
			high = MathUtils.roundDouble(price, MathUtils.TWO_DEC_DOUBLE_FORMAT);
			// set the initial volume
			volume = t.getSize();


Also, we created FxMarketPxFeeder.java class which will be played as the financial market data feeder, it reads our trades file twtr.csv which contains the intraday trades for Twitter stock, it feeds the JfreeCandlestickChart.java using the callback method onTrade(Trade t) to Aggregate the (open, high, low, close, volume) based on the predefined time interval (1 minute). then, it updates the JfreeCandlestickChart using the addCandel(long time, double o, double h, double l, double c, long v) method.


package com.fx.jfree.chart.common;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.fx.jfree.chart.candlestick.JfreeCandlestickChart;
import com.fx.jfree.chart.model.Trade;
import com.fx.jfree.chart.utils.TimeUtils;

 * The Class FxMarketPxFeeder.
 * @author ashraf
public class FxMarketPxFeeder {

	private JfreeCandlestickChart jfreeCandlestickChart;
	private String stockTradesFile; 
	private int simulationTime;
	private ExecutorService executorService;
	public FxMarketPxFeeder(JfreeCandlestickChart jfreeCandlestickChart, String stockTradesFile, int simulationTime) {
		this.executorService = Executors.newCachedThreadPool();
		this.stockTradesFile = stockTradesFile;
		this.jfreeCandlestickChart = jfreeCandlestickChart;
		this.simulationTime = simulationTime;

	public void run() {
		executorService.execute(() -> read());

	private void read() {
		try (BufferedReader br = new BufferedReader(
				new InputStreamReader(this.getClass().getResourceAsStream(stockTradesFile)))) {
			while (true) {
				String line = br.readLine();
				if (line != null) {
					// Parse line and convert it to trade
					String[] tradeElements = line.split(Constants.DELIMITER);
					Trade t = new Trade(tradeElements[Constants.STOCK_IDX],
					// Add trade to the jfreeCandlestickChart 
				} else {
		} catch (IOException e) {
		} catch (InterruptedException e) {



Notice that twtr.csv file contains the intraday Twitter stock trades, each trade has stock, timeprice and shares.



5. Running the Jfree Candlestick Chart

We create JfreeCandlestickChartDemo.java class which serve as main class to running our example.


package com.fx.jfree.chart.demo;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

import com.fx.jfree.chart.candlestick.JfreeCandlestickChart;
import com.fx.jfree.chart.common.FxMarketPxFeeder;

 * The Class JfreeCandlestickChartDemo.
 * @author ashraf
public class JfreeCandlestickChartDemo extends JPanel {

     * Create the GUI and show it.  For thread safety,
     * this method should be invoked from the
     * event-dispatching thread.
    private static void createAndShowGUI() {
        //Make sure we have nice window decorations.

        //Create and set up the window.
        JFrame frame = new JFrame("JfreeCandlestickChartDemo");

        //Create and set up the chart.
        JfreeCandlestickChart jfreeCandlestickChart = new JfreeCandlestickChart("TWTR");
        new FxMarketPxFeeder(jfreeCandlestickChart, "/twtr.csv", 2).run();

        //Disable the resizing feature
        //Display the window.

    public static void main(String[] args) {
        //creating and showing this application's GUI.
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {



Figure 2: Jfree Candlestick Chart

6. Download the Source Code

This was an example to show how to create a Jfree candlestick chart.

You can download the full source code of this example here: JfreeCandlestickChartExampleCode.zip

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!


1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design


and many more ....


Receive Java & Developer job alerts in your Area


Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

1 Comment
Newest Most Voted
Inline Feedbacks
View all comments
3 years ago

Hi, Thanks for the demo. I ran it ok in eclipse, but the chart is very slow to construct. I wanted to try running it from the CLI but I get errors about missing packages and symbols. I think I need to list the class paths in the command but can’t work it out. Any recommendations?