Computer Science 210
Data Structures

Fall 2017, Siena College

RatioListApplet BlueJ Project

Click here to download a BlueJ project for RatioListApplet.

RatioListApplet Source Code

The Java source code for RatioListApplet is below. Click on a file name to download it.

// <applet code='RatioListApplet' width='400' height='450'></applet>
 * Example RatioListApplet: a simple Applet to manipulate
 * a RatioList - a list of Ratio objects
 * Jim Teresco, The College of Saint Rose, CSC 523, Summer 2014

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.BoxLayout;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSeparator;
import javax.swing.JTextField;

public class RatioListApplet extends JApplet implements ActionListener {

    // GUI components
    private JTextField displayNumerator, displayDenominator;
    private JButton insertButton, sumButton, minButton, maxButton, reduceButton, reduceAllButton, showAllButton;

    // our RatioList, which is null until the first is inserted
    private RatioList ratios;

    public void init() {

        Container contentPane = getContentPane();

        // a bigger font for our display label and text fields
        Font biggerFont = new Font("Sans-Serif", Font.BOLD, 24);
        Font biggestFont = new Font("Fixed", Font.PLAIN, 48);

        // a JPanel for the center that displays the "current" ratio
        JPanel currentPanel = new JPanel();
        JLabel currentLabel = new JLabel("Display value:");
        // another JPanel to create the ratio display
        JPanel ratioPanel = new JPanel();
        ratioPanel.setLayout(new BoxLayout(ratioPanel, BoxLayout.PAGE_AXIS));
        displayNumerator = new JTextField("0", 5);
        ratioPanel.add(new JSeparator());
        displayDenominator = new JTextField("1", 5);
        contentPane.add(currentPanel, BorderLayout.CENTER);

        // a JPanel for the buttons across the bottom
        JPanel buttonPanel = new JPanel(new GridLayout(0, 1));
        insertButton = setupButton("Insert Current", buttonPanel);
        sumButton = setupButton("Set Current to Sum", buttonPanel);
        minButton = setupButton("Set Current to Min", buttonPanel);
        maxButton = setupButton("Set Current to Max", buttonPanel);
        reduceButton = setupButton("Reduce Current to Lowest Terms", buttonPanel);
        reduceAllButton = setupButton("Reduce All to Lowest Terms", buttonPanel);
        showAllButton = setupButton("Show All Ratios", buttonPanel);
        contentPane.add(buttonPanel, BorderLayout.SOUTH);

    // a private method to create, insert, and set the listener for our buttons
    private JButton setupButton(String label, JPanel addTo) {

        JButton me = new JButton(label);
        return me;

    // a private method to check if the contents of a JTextField represent a valid
    // integer value
    private static boolean isValidInt(JTextField f) {

        String text = f.getText();
        try {
        catch (NumberFormatException e) {
            return false;
        return true;

    // helper method to display a given ratio in the display area
    private void displayRatio(Ratio r) {


    // helper method to get a Ratio based on current contents of the text fields,
    // and returns null (after showing error dialog) if the fields are not valid
    // to construct a Ratio
    private Ratio ratioOfDisplay() {
        // we need to take the value on the display and create a new ratio out of it

        // we need to verify that the value displayed is valid to use as a ratio
        // first, check that the text fields have numbers in them
        boolean numValid = isValidInt(displayNumerator);
        boolean denValid = isValidInt(displayDenominator);
        String message = "";
        if (!numValid) {
            message += "Could not parse numerator as an integer value!\n";
        if (!denValid) {
            message += "Could not parse denominator as an integer value!\n";
        if (!numValid || !denValid) {
            JOptionPane.showMessageDialog(null, message, "Invalid Entry", JOptionPane.ERROR_MESSAGE);
            return null;

        // we know they're numbers, so let's get them
        int num = Integer.parseInt(displayNumerator.getText());
        int den = Integer.parseInt(displayDenominator.getText());

        // make sure we're not dividing by zero
        if (den == 0) {
            JOptionPane.showMessageDialog(null, "Denominator cannot be 0", "Invalid Entry", JOptionPane.ERROR_MESSAGE);
            return null;

        // if we get here, things are good, construct and return a Ratio
        return new Ratio(num, den);

    // handle all those button presses
    public void actionPerformed(ActionEvent e) {

        if (e.getSource() == insertButton) {
            // we need to take the value on the display and create a new ratio out of it
            // and add it to our collection

            Ratio newOne = ratioOfDisplay();
            if (newOne != null) {
                // things are valid, so let's construct a Ratio and make it the new
                // first entry in our RatioList
                ratios = new RatioList(newOne, ratios);
        else if (e.getSource() == showAllButton) {
            // we just want to print out all of the ratios in our collection
            // so we'll put them up in a dialog box
            String message;
            if (ratios == null) {
                message = "No ratios in list.";
            else {
                message = ratios.toString();
            JOptionPane.showMessageDialog(null, message);

        else if (e.getSource() == sumButton) {
            // we need to compute the sum and display it
            if (ratios == null) {
                displayRatio(new Ratio(0,1));
            else {
        else if (e.getSource() == minButton) {
            if (ratios == null) {
                JOptionPane.showMessageDialog(null, "No ratios in list.");
        else if (e.getSource() == maxButton) {
            if (ratios == null) {
                JOptionPane.showMessageDialog(null, "No ratios in list.");
            else {
        else if (e.getSource() == reduceButton) {
            // get the Ratio from the display text fields
            Ratio displayed = ratioOfDisplay();
            if (displayed != null) {
        else if (e.getSource() == reduceAllButton) {
            if (ratios == null) {
                JOptionPane.showMessageDialog(null, "No ratios in list.");
            else {

 * A recursive data structure (list) of Ratio objects with some
 * useful methods to manage such a list
 * Jim Teresco, The College of Saint Rose, CSC 523, Summer 2014

public class RatioList {

    // our instance variables have room for one Ratio, and
    // then a list of other ratios -- which is exactly
    // the structure we are defining -- so we can define this
    // structure *recursively*
    private Ratio first;
    private RatioList rest;
    // we construct a RatioList from a Ratio and another RatioList,
    // which would be null when constructing a brand new RatioList
    // with its first element
    public RatioList(Ratio first, RatioList rest) {
        this.first = first; = rest;
    // a method to compute the sum of all ratios
    // it's recursive
    public Ratio getSum() {
        // if there is no rest, the sum is just first
        if (rest == null) return first;
        // otherwise, we have to compute the sum of the rest (using
        // this method) and then add in first, using Ratio's add method
        return first.add(rest.getSum());
    // to find the minimum ratio, we also use a recursive method.
    // the minimum is the smaller of first and the minimum of the rest,
    // which we compute using this method recursively
    public Ratio getMin() {
        // the smallest out of a single ratio is that ratio
        if (rest == null) return first;
        // otherwise, find the min of the rest and compare to first
        Ratio minOfRest = rest.getMin();
        if (minOfRest.getDecimalValue() < first.getDecimalValue()) {
            return minOfRest;
        else {
            return first;
    // max is the same idea
    public Ratio getMax() {
        // the largest out of a single ratio is that ratio
        if (rest == null) return first;
        // otherwise, find the max of the rest and compare to first
        Ratio maxOfRest = rest.getMax();
        if (maxOfRest.getDecimalValue() > first.getDecimalValue()) {
            return maxOfRest;
        else {
            return first;
    // reduce all Ratios in the list to lowest terms
    public void reduceAll() {
        // reduce the one Ratio we have
        // and if there are more, reduce recursively
        if (rest != null) rest.reduceAll();
    // the toString method is recursive!  To print this whole RatioList,
    // we concatenate the result of first's toString with a recursive
    // call to this toString method.  But only do the latter when rest
    // is not null (we are not at the end of the list)
    public String toString() {
        String answer = first.toString();
        if (rest != null) {
            answer += ", " + rest.toString();
        return answer;

 * Example Ratios -- the Ratio class
 * This class encapsulates a numerator and denominator and
 * includes the capability to set the numerator or denominator,
 * retrieve the numerator or denominator, retrieve the decimal
 * equivalent of the ratio, and return a "pretty" String 
 * representation of the ratio
 * This version includes a non-destructive method to add another
 * ratio to this and return a new ratio that contains the sum
 * Jim Teresco, The College of Saint Rose, CSC 202, Fall 2012
 * CSC 523, Summer 2014
 * $Id$

public class Ratio {

    // Instance variables for the two integers, one each for the numerator
    // and denominator.

    private int numerator;
    private int denominator;
    // our straightforward constructor
    public Ratio(int num, int den) {
        numerator = num;
        denominator = den;
    // Mutators for numerator and denominator
    public void setNumerator(int num) {
        numerator = num;
    public void setDenominator(int den) {
        denominator = den;
    // And some accessors
    public int getNumerator() {
        return numerator;
    public int getDenominator() {
        return denominator;
    public double getDecimalValue() {
        return 1.0 * numerator / denominator;
    // print our simple string representation
    public String toString() {
        return numerator + "/" + denominator;
    // a non-destructive add method that adds another ratio to this
    // one and returns a new one (leaving this and other unchanged)
    public Ratio add(Ratio other) {
        return new Ratio(numerator*other.denominator + denominator*other.numerator,
    // a recursive method to compute greatest common divisor using Euclid's method
    public static int gcd(int a, int b) {
        if (a == 0) return b;
        if (a > b) return gcd(b, a);  // so below we can assume b>=a
        return gcd(b%a, a);
    // Reduce this ratio to lowest terms.  To do so, we find the greatest common
    // divisor of the numerator and denominator, then divide both
    // numerator and denominator by that value
    public void reduce() {
        int divideBy = gcd(numerator, denominator);
        numerator /= divideBy;
        denominator /= divideBy;