Java - Find Minimum and Maximum value of an array of Strings

Question

I'm new to programming in java. The below source code is found in a book, when i try to execute the program it is showing some incorrect data.

public class Pair<T> {

    private T first;
    private T second;

    public Pair() {
        first = null;
        second = null;
    }

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void setFirst(T newValue) {
        first = newValue;
    }

    public void setSecond(T newValue) {
        second = newValue;
    }  
}

Logic to find the min and max value of the string array

public class ArrayAlg {

    public static Pair<String> minmax(String[] arr) {
        if (arr == null || arr.length == 0)
            return null;

        String min = arr[0];
        String max = arr[0];

        for (int i = 1; i < arr.length; i++) {
            if (min.compareTo(arr[i]) > 0)
                min = arr[i];
            if (max.compareTo(arr[i]) < 0)
                max = arr[i];
        }
        return new Pair<String>(min, max);

    }
}

public static void main(String[] args) {

        String[] words = { "Mary", "had", "a", "little", "lamb" };
        Pair<String> obj = ArrayAlg.minmax(words);
        System.out.println("Minvalue " + obj.getFirst());
        System.out.println("Maxvalue " + obj.getSecond());

    }

If you execute the above program, it displays Minvalue = Mary and MaxValue = little. The value a in the String array is the Minimum Value but in this case it is showing Mary as the Min Value.
Can anyone tell me the better approach to find the Minimum and Maximum value in the String array?

Answer 1

The output you got is the correct output, since the natural ordering of Strings is lexicographical order, in which upper case letters come before lower case letters. Hence Mary is the "smallest" String.

In order not to use the natural ordering, don't use String's compareTo method. Instead you can implement whatever logic you see fit to determine which String is smaller. One way of introducing alternative ordering is passing a Comparator<String> instance to your minmax method and using its compare method to compare the Strings.

Answer 2

I think, for you purposes it's better to use String method compareToIgnoreCase().

But it depends on you understanding what does Minimum string and Maximum string is.

Also, there is preffered way to compare any objects - via Comparator.

public static Pair<String> minmax(String[] arr) {
    if (arr == null || arr.length == 0)
        return null;

    Arrays.sort(arr, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareToIgnoreCase(o2); // to compare by lexicographical order
            //return o1.length() - o2.lenth(); // to compare by length
        }
    });

    return new Pair<String>(arr[0], arr[arr.length - 1]);
}

Here are some links to follow:

• Java Comparator class to sort arrays
• https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html
• http://www.tutorialspoint.com/java/java_using_comparator.htm

Answer 3

You will need to use a Comparator for this. You can sort the words alphabetically, ignoring case, by using the String.CASE_INSENSITIVE_ORDER Comparator.

In Java 8 this can be achieved easily using Lambdas:

public final Pair<String> miniMax(final String[] words) {
    final String min = Arrays.stream(words).min(String.CASE_INSENSITIVE_ORDER).orElse(null);
    final String max = Arrays.stream(words).max(String.CASE_INSENSITIVE_ORDER).orElse(null);
    return new Pair<>(min, max);
}

Testing:

String[] words = { "Mary", "had", "a", "little", "lamb" };
System.out.println(miniMax(words));

Output:

a, Mary

Answer 4

compareTo() compares the strings lexicographically, meaning that uppercase letters come before lowercase letters, since that is the order in Unicode. Instead, do one of the following:

• Use compareToIgnoreCase()

• Use a case-insensitive Comparator, readily available from String.CASE_INSENSITIVE_ORDER

• Use a full language-specific Comparator, that will order special characters and international letters like you would see in a book index, available from Collator.getInstance()

Alternatively, for a good Java 8 implementation, see answer by arizzle.

So, your loop could be:

for (int i = 1; i < arr.length; i++) {
    if (min.compareToIgnoreCase(arr[i]) > 0)
        min = arr[i];
    if (max.compareToIgnoreCase(arr[i]) < 0)
        max = arr[i];
}

Or:

Comparator<String> comp = Collator.getInstance();
for (int i = 1; i < arr.length; i++) {
    if (comp.compare(min, arr[i]) > 0)
        min = arr[i];
    if (comp.compare(max, arr[i]) < 0)
        max = arr[i];
}