How to use a separate comparator class to sort an array list

Question

Yeah this is homework but I am very stuck on what is wanted. The comparator class should implement java.util.Comparator, and the second argument of the sort() method should be an instance of my Comparator class.

So far my comparator class looks like:

import java.util.Comparator;

public class Compare implements Comparator<Rational> {

    public int compare1(int a, int b){
        int z = 0;

        if(a > b)
            z = 1;
        else if(b > a)
            z = -1;
        return z;
    }

    @Override
    public int compare(Rational a, Rational b) {
        // TODO Auto-generated method stub
        return 0;
    }
}

I have a separate method to sort the array but this method uses compareTo()

public static Collection<Rational> sort1(List<Rational> list){
    List<Rational> sortedList1 = new ArrayList<Rational>();

    for (int i=0;i < list.size();i++) { //iterating through list
        Rational currentValue = list.get(i);

        int pos = sortedList1.size(); 
        for (int j=0;j<sortedList1.size();j++) {
            int comparison = currentValue.compareTo(sortedList1.get(j)); //comparing
            //this is the right position if the currentValue is greater or equal 
            //to the sorted value at this position
            if(comparison > 0 || comparison == 0){
                pos = j;
                break;
            }
        }
        sortedList1.add(pos, currentValue);
    }
    return sortedList1;
}

What should I use this method but using my separate comparator class? I'm totally lost on what I should do.

My Rational Class looks like:

public class Rational implements Comparable {

    private int num;   // the numerator
    private int den;   // the denominator

    // create and initialize a new Rational object
    public Rational(int numerator, int denominator) {
        if (denominator == 0) {
            throw new RuntimeException("Denominator is zero");
        }
        int g = gcd(numerator, denominator);
        num = numerator / g;
        den = denominator / g;

    }

    // return string representation of (this)
    public String toString() {
        if (den == 1) {
            return num + "";
        } else {
            return num + "/" + den;
        }
    }

    // return (this * b)
    public Rational times(Rational b) {
        return new Rational(this.num * b.num, this.den * b.den);
    }

    // return (this + b)
    public Rational plus(Rational b) {
        int numerator = (this.num * b.den) + (this.den * b.num);
        int denominator = this.den * b.den;
        return new Rational(numerator, denominator);
    }

    // return (1 / this)
    public Rational reciprocal() {
        return new Rational(den, num);
    }

    // return (this / b)
    public Rational divides(Rational b) {
        return this.times(b.reciprocal());
    }

    /** ***********************************************************************
     * Helper functions
    ************************************************************************ */
    // return gcd(m, n)
    private static int gcd(int m, int n) {
        if (0 == n) {
            return m;
        } else {
            return gcd(n, m % n);
        }
    }

    /** ***********************************************************************
     * Test client
    ************************************************************************ */
    public static void main(String[] args) {
        Rational x, y, z;

        // 1/2 + 1/3 = 5/6
        x = new Rational(1, 2);
        y = new Rational(1, 3);
        z = x.plus(y);
        System.out.println(z);

        // 8/9 + 1/9 = 1
        x = new Rational(8, 9);
        y = new Rational(1, 9);
        z = x.plus(y);
        System.out.println(z);

        //  4/17 * 7/3 = 28/51
        x = new Rational(4, 17);
        y = new Rational(7, 3);
        z = x.times(y);
        System.out.println(z);

        // 203/16957 * 9299/5887 = 17/899
        x = new Rational(203, 16957);
        y = new Rational(9299, 5887);
        z = x.times(y);
        System.out.println(z);

        // 0/6 = 0
        x = new Rational(0, 6);
        System.out.println(x);

    }

    public int compareTo(final Rational a, final Rational b) {
        return b.compareTo(a);
    }

    @Override
    public int compareTo(Rational arg0) {
        // TODO Auto-generated method stub
        return 0;
    }
}

Answer 1

Try This:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Rational{

private static int gcd(int m, int n) {
    if (0 == n) return m;
    else return gcd(n, m % n);
}

private int num;   // the numerator
private int den;   // the denominator


public int getNum() {
    return num;
}



public void setNum(int num) {
    this.num = num;
}



public int getDen() {
    return den;
}



public void setDen(int den) {
    this.den = den;
}



// create and initialize a new Rational object
public Rational(int numerator, int denominator) {
    if (denominator == 0) {
        throw new RuntimeException("Denominator is zero");
}

int g = Rational.gcd(numerator, denominator);
num = numerator   / g;
den = denominator / g;

}



// return string representation of (this)
public String toString() {
if (den == 1) { return num + "";        }
else          { return num + "/" + den; }
}

// return (this * b)
public Rational times(Rational b) {
return new Rational(this.num * b.num, this.den * b.den);
}


// return (this + b)
public Rational plus(Rational b) {
int numerator   = (this.num * b.den) + (this.den * b.num);
int denominator = this.den * b.den;
return new Rational(numerator, denominator);
}

// return (1 / this)
public Rational reciprocal() { return new Rational(den, num);  }

// return (this / b)
public Rational divides(Rational b) {
    return this.times(b.reciprocal());

}


}


class RationalComparator implements Comparator<Rational>{

@Override
public int compare(Rational r1, Rational r2) {
    if (r1.getNum() / r1.getDen() == r2.getNum() / r2.getDen()){
        return (0);
        }
        else if (r1.getNum() / r1.getDen() < r2.getNum() / r2.getDen()){
        return (-1);
        }
        else{
        return (1);


        }

    }

}

 class UsingComparator {

    public static void main(String[] args) {

        Rational r1=new Rational(5, 2);
        Rational r2=new Rational(1, 2);

        List<Rational>rationalList=new ArrayList<Rational>();

        rationalList.add(r1);
        rationalList.add(r2);
        System.out.println(rationalList);

        Collections.sort(rationalList,new RationalComparator());
        System.out.println(rationalList);


    }

}

Answer 2

I would use

Collections.sort(list, RationalComparator.INSTANCE);

where the comparator looks like

enum RationalComparator implements Comparator<Rational> {
   INSTANCE;

   public int compare(Rational a, Rational b) {
       // do your comparison here
   }
}

Answer 3

You give your answer yourself: "and the second argument of the sort() method should be an instance of my Comparator class." So the first line changes to

public static Collection<Rational> sort1(List<Rational> list,final Comparator<Rational,Rational> comparator){

This parameter can be used for comparing in your method.

comparator.compare(...)

Answer 4

public class MyCompare implements Comparator<Rational> {

@Override
public int compare(final Rational a, final Rational b) {
    return a.compareTo(b);
}
}

And then:

Collections.sort(list, new MyCompare());