Assignment 2b

In this part of the assignment, you will write a program that accepts a set of strings of people's names, of the form:

(I've intentionally mixed up the case of several of these strings to ensure that you write the code to set the case properly.)

Explanation: In some languages, last (family) names may consist of multiple words. For example, in French, the name "de la Grange" is a family name, and in German, the name "von Trapp" is a family name. Typically, the last word is a proper name (often a place name) and so should have its first letter upcased, while the words before it are not proper names (they are often prepositions and/or definite articles) and should not be upcased. The words "de la" in French mean "of the" or "from the", and the word "von" in German means "of" or "from".

Here are some skeleton Java sources which I expect you to start from. Note that I've already done a lot of the work for you, since the main point of this exercise is for you to learn how to use the String class. The structure of the program is already present; all you have to do is fill in the gaps with your code. Look for [fill in here] indicators, for where you have to supply code.

package names;

/**
*   Class to represent a person's name.
*/
public class Name implements Comparable
{
    /**
    *   Constructor
    */
    public Name(String first, String last)
    {
        m_first = first;
        m_last = last;
    }

    /**
    *   Returns whether the names are to be sorted
    *   by last name (true) or first name (false)
    */
    public boolean isSortByLast()
    {
        return m_sortByLast;
    }

    /**
    *   Sets whether the names are to be sorted
    *   by last name (true) or first name (false)
    */
    public void setSortByLast(boolean b)
    {
        m_sortByLast = b;
    }

    /**
    *   Compare this object with another object.
    *   (The other object must also be an instance of Name)
    *   NOTE: This comparison is case insensitive;  that is,
    *         letters are sorted regardless of case.
    */
    public int compareTo(Object o)
    {
        Name that = (Name) o;
        String comp1, comp2;
        int result = 0;
        if (m_sortByLast)
        {
            [fill in here]
        }
        else
        {
            [fill in here]
        }
        return result;
    }

    /**
    *   Returns a string of the form:
    *       <first-name> <last-name>
    *   where the two parts of the name are separated by a space.
    */
    public String toString()
    {
        return m_first + " " + m_last;
    }

    ///// Private data //////
    private boolean m_sortByLast = true;
    private String m_first;
    private String m_last;
}

package names;

import java.util.Arrays;

/**
*   Class to test the sorting of Names.
*/
public class NamesTest
{
    /**
    *   Main entry point.
    */
    public static void main(String[] args)
    {
        Name[] names = new Name[m_names.length];
        // populate the array with normalized names
        for (int i = 0; i < m_names.length; i++)
        {
            String name = m_names[i];
            String first = getFirstName(name);
            String last  = getLastName(name);
            names[i] = new Name(first, last);
        }
        // Sort it by last name
        Arrays.sort(names);
        System.out.println("   Names sorted by last name:");
        for (int i = 0; i < names.length; i++)
        {
            System.out.println(names[i]);
        }
        // Sort it by first name
        for (int i = 0; i < names.length; i++)
            names[i].setSortByLast(false);
        Arrays.sort(names);
        System.out.println("   Names sorted by first name:");
        for (int i = 0; i < names.length; i++)
        {
            System.out.println(names[i]);
        }
    }

    /**
    *   Extracts the first name from the specified name,
    *   normalizes it, and then returns it.
    */
    private static String getFirstName(String name)
    {
        // Get rid of any leading or trailing space
            [fill in here]
        // Find the first space
            [fill in here]
        // Extract everything before it as the first name
            [fill in here]
        // Initial cap the entire first name
            [fill in here]
        // Return the first name
    }

    /**
    *   Extracts the last name from the specified name,
    *   normalizes it, and then returns it.
    */
    private static String getLastName(String name)
    {
        // Get rid of any leading or trailing space
            [fill in here]
        // Find the first space
            [fill in here]
        // Extract everything beyond it as the last name
            [fill in here]
        // Find out whether it has an embedded space, 
        // & if it does, find the last one in the name
            [fill in here]
        if ([fill in here]) // No space found
        {
            // No space found, so just Init cap the entire last name
            [fill in here]
        }
        else
        {
            // Space found, so extract the first part
            [fill in here]
            // and lowercase it
            [fill in here]
            // Now extract the last part
            [fill in here]
            // and init cap it
            [fill in here]
            // Then reconstruct the name again, 
            // from the first and last parts
            [fill in here]
        }
        // Return the resulting normalized last name
            [fill in here]
    }

    /**
    *   Utility method to take a string (name) and set the
    *   first character to uppercase, and all the other
    *   characters to lowercase.
    */
    private static String initialCap(String name)
    {
            [fill in here]
    }

    //// Private data /////

    // The initial list of un-normalized names.
    private static String[] m_names =
    {
        "fred bloggs", "MARY STUART",
        "eRIC SuttoN", "Francis Bailey",
        "Archimedes von trapp", "Abel GRISWOLD",
        "Jeffrey Guay", "Alan Swasinski",
        "Leroy de la Grange", "Don Ho"
    };
}

Notes on the Above:

The key to understanding this is to look up the java.lang.Comparable interface in the javadocs (It's in JDK 1.2 on up). Class Name implements the Comparable interface, which means that it's required to implement the method:

Here's what the JDK 1.2 docs say about the lang.util.Arrays class's sort() method (I've underlined the critical point):

Part B: Practice with Strings

Make sure that each string is properly formatted:

Sort the names in ascending first name order.

Sort the names in ascending last name order.

Notes on the Above:

sort

compareTo