To solve this problem you need to complete the definition of the Roster class provided below. The class includes an inner class Student that includes basic information about students. Each instance of the Roster class contains an internal ArrayList to which students can be added and removed at will by invoking the add and remove methods. Students can also be accessed from the list by calling the get(i) method.

Your main objective is to provide a static method named getSortedRoster(Comparator) that returns a new ArrayList with all the students sorted according to the provided Comparator object.

You must also complete the definition of a specific Comparator that sorts students first increasingly by last name and second increasingly by first name (lexicographic). That is, the order of student first names will only be considered when two students have the same last name (to break ties).

Given class:

import java.util.ArrayList;

import java.util.Comparator;

public class Roster {

private ArrayList roster;

public Roster() {

roster = new ArrayList();

}

public enum Sex {

Male,

Female

}

public static class Student {

String id;

String firstName;

String lastName;

Sex sex;

double gpa;

public Student(String id, String firstName, String lastName, Sex sex, double gpa) {

super();

this.id = id;

this.firstName = firstName;

this.lastName = lastName;

this.sex = sex;

this.gpa = gpa;

}

public String getId() { return id; }

public String getFirstName() { return firstName; }

public String getLastName() { return lastName; }

public Sex getSex() { return sex; }

public double getGpa() { return gpa; }

public void setId(String id) { this.id = id; }

public void setFirstName(String firstName) { this.firstName = firstName; }

public void setLastName(String lastName) { this.lastName = lastName; }

public void setSex(Sex sex) { this.sex = sex; }

public void setGpa(float gpa) { this.gpa = gpa; }

}

public void add(Student s) { roster.add(s); }

public void remove(Student s) { roster.remove(s); }

public Student get(int i) { return roster.get(i); }

public ArrayList getRoster() {

return roster;

}

public static class MyComparator implements Comparator {

@Override

public int compare(Student o1, Student o2) {

if(o1.firstName.compareTo(o2.firstName) == 0){

return o1.firstName.compareTo(o2.firstName);

}

else if(o1.firstName.compareTo(o2.firstName) >= 0 ||

o2.firstName.compareTo(o1.firstName) <= 0){

return o1.firstName.compareTo(o2.firstName);

}

return 0;

}

}

public ArrayList getSortedRoster(Comparator comparator) {

// YOUR CODE HERE

}

}

Given test case:

import static org.junit.Assert.*;

import java.util.ArrayList;

import java.util.Comparator;

import org.junit.Before;

import org.junit.Test;

public class RosterTest {

Comparator myComparator = new Roster.MyComparator();

Roster.Student s1 = new Roster.Student("801-82-0203", "John", "Doe", Roster.Sex.Male, 3.5);

Roster.Student s2 = new Roster.Student("801-82-0000", "Jane", "Doe", Roster.Sex.Female, 4.0);

Roster.Student s3 = new Roster.Student("801-82-0103", "John", "Bar", Roster.Sex.Male, 3.9);

Roster.Student s4 = new Roster.Student("801-84-0103", "Jane", "Foo", Roster.Sex.Female, 3.5);

Roster rosterEmpty = new Roster();

Roster rosterForward = new Roster();

Roster rosterReverse = new Roster();

@Before

public void setUp() {

rosterForward.add(s3);

rosterForward.add(s2);

rosterForward.add(s1);

rosterForward.add(s4);

rosterReverse.add(s4);

rosterReverse.add(s1);

rosterReverse.add(s2);

rosterReverse.add(s3);

}

@Test

public void testComparatorAlone1() {

assertTrue("MyComparator returns incorrect result", myComparator.compare(s1, s1) == 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s2, s2) == 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s3, s3) == 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s4, s4) == 0);

}

@Test

public void testComparatorAlone2() {

assertTrue("MyComparator returns incorrect result", myComparator.compare(s1, s2) > 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s2, s1) < 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s1, s4) < 0);

assertTrue("MyComparator returns incorrect result", myComparator.compare(s4, s1) > 0);

}

@Test

public void testSortEmptyList() {

assertTrue("getSortedRoster returns incorrect result", rosterEmpty.getSortedRoster(myComparator).size() == 0);

}

@Test

public void testSortSorted() {

ArrayList sorted = rosterForward.getSortedRoster(myComparator);

assertFalse("getSortedRoster returns incorrect result", sorted == rosterForward.getRoster());

assertTrue("getSortedRoster returns incorrect result", sorted.size() == rosterForward.getRoster().size());

assertTrue("getSortedRoster returns incorrect result", sorted.get(0).equals(rosterForward.get(0)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(1).equals(rosterForward.get(1)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(2).equals(rosterForward.get(2)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(3).equals(rosterForward.get(3)));

}

@Test

public void testSortReverse() {

ArrayList sorted = rosterReverse.getSortedRoster(myComparator);

assertTrue("getSortedRoster returns incorrect result", sorted.size() == rosterForward.getRoster().size());

assertTrue("getSortedRoster returns incorrect result", sorted.get(0).equals(rosterReverse.get(3)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(1).equals(rosterReverse.get(2)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(2).equals(rosterReverse.get(1)));

assertTrue("getSortedRoster returns incorrect result", sorted.get(3).equals(rosterReverse.get(0)));

}

}