case 2:
course = JOptionPane.showInputDialog(
"Please enter the name of the course.");
input = JOptionPane.showInputDialog("Enter the semester, "
+ "typing first the year \nand then the season code "
+ "\n(i.e. Spring = 1, Summer = 2, Fall = 3).");
semester = Integer.parseInt(input);
crn = JOptionPane.showInputDialog("Enter the CRN.");
Course c = new Course(course, semester, crn);
roosevelt.addCourses(c);
break;

public class Course implements Serializable, Comparable<Course> {
private String name;
private int semester;
private String crn;
private List<Student> students;
public Course(String n, int s, String crn){
name = n;
semester = 0;
crn = "CRN";
students = new SortedLinkedList<Student>();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSemester() {
return semester;
}
public void setSemester(int semester) {
this.semester = semester;
}
public String getCrn() {
return crn;
}
public void setCrn(String crn) {
this.crn = crn;
}
@Override
public int compareTo(Course x){
if (semester < x.getSemester()){
return -1;
}
else if (semester > x.getSemester()){
return 1;
}
else
{
return 0;
}
}
public void addStudent(Student s){
students.add(s);
}
public void listStudents(){
ListIterator<Student> iter = students.listIterator();
Student s;
String output ="";
while(iter.hasNext()){
s = iter.next();
output = output + s.getFirstName() + " " + s.getLastName() + "\n";
}
JOptionPane.showMessageDialog(null, output);
}
}

public class University implements Serializable {

    private String name;
    private Map<String, Student> students;
    private Map<String, Course> courses;

    public University(String n){
        name = n;
        students = new HashMap<String, Student>();
        courses = new HashMap<String, Course>();

        }
    public void addStudents(Student s){
        if(students.containsKey(s.getIdNumber()))
            System.out.println("Invalid Key");
        else
            students.put(s.getIdNumber(), s);
    }
    public void addCourses(Course c){
        if(courses.containsKey(c.getCrn())){
            System.out.println("Invalid Key");
        }
        else
        {
            courses.put(c.getCrn(), c);
        }
    }
    public Course getCourse(String id){
        return courses.get(id);
    }
    public Student getStudent(String id){
        return students.get(id);
    }
    public void listStudents() {

         Collection<Student> values = students.values();
                        for(Student s : values)
                           {
                               System.out.println(s.getIdNumber() + "   "
                                   + s.getFirstName() + "   " +
                                       s.getLastName());
                        }

    }
}
public class Student implements Serializable, Comparable <Student> {

    private String firstName;
    private String lastName;
    private String idNumber;
    private List <Course> classes;

    public Student() {
    }

    public Student(String firstName, String lastName, String idNumber) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.idNumber = idNumber;
        classes = new SortedLinkedList<Course>();
    }

    public String getFirstName() {
        return firstName;
    }

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

    public String getLastName() {
        return lastName;
    }

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

    public String getIdNumber() {
        return idNumber;
    }

    public void setIdNumber(String idNumber) {
        this.idNumber = idNumber;
    }

    public void registerClass(Course c){
        classes.add(c);
    }

    public int compareTo(Student x) {
        int result = lastName.compareTo(x.getLastName());
        if(result != 0){
            return result;
        }
        else{
            return firstName.compareTo(x.getFirstName());
        }

    }

    public void listCourses(){
        ListIterator<Course> iter = classes.listIterator();
        Course c;
        String output ="";
        while(iter.hasNext()){
            c = iter.next();
            output = output + c.getCrn() + " " + c.getName()
                    + " " + c.getSemester() + "\n";
    }
        JOptionPane.showMessageDialog(null, output);
}
}
public class SortedLinkedList<E extends Comparable> extends LinkedList<E>
implements Serializable
{
    public SortedLinkedList()
    {
        super();
    }

    @Override
    public boolean add(E x)
    {
       ListIterator<E> iter = this.listIterator();
       E p;
       boolean bigger = false;

       while(iter.hasNext() && !bigger)
       {
           p = iter.next();
           if(p.compareTo(x) > 0)
           {
               bigger = true;
               iter.previous();
               iter.add(x);
           }
       }

       if(!bigger)
       {
           iter.add(x);
       }
       return true;
    }
}