CompareTo() for finding the shortest/longest string in an array

Question

I am trying to solve a exorcise that is supposed to learn me about the Comparable<T> interface. It tells me to find the shortest and longest string in a string array.

I think I am supposed to make my own compareTo() -method because the String.compareTo() method sorts alphabetically. But I can't get what my method should look like.

This is my code so far:

class ComparableTest implements Comparable<String> {

    public static void main(String[] args) {
        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};
        String tempSto = arr[0]; //long string
        String tempLit = arr[0]; //short string
        for(String e : arr) {
            if(e.compareTo(tempSto) > 0) {
                tempSto = e;
            }
            if(e.compareTo(tempLit) < 0) {
                tempLit = e;
            }
        }
        System.out.println("Longest string is: " + tempSto);
        System.out.println("Shortest string is: " + tempLit);
    }
}

Answer 1

As you mentioned, you should implement your own Comparator, based on the String's length, not its alphabetical contents. E.g.:

public class StringLengthComparator extends Comparator<String> {
    @Override
    public int compare (String s1, String s2) {
        return Integer.compare(s1.length(), s2.length();
    }
}

Once you've done that, you can use it to find the shortest string in the array, or just reuse Collections#min(Collection, Comparator) to do the heavy lifting for you:

String shortest = 
    Collections.min(Arrays.asList(arr), new StringLengthComparator());

Answer 2

If your class implements the Comparable interface, i guess you have to override the compareTo method, and compare the length of the two String compared.

Answer 3

You can use a comparable to sort a list according to your own needs. This means in your case, that the highest and lowest number of characters in a string is relevant for the comparing. So, you subtract those value from each other in the comparing function. If you have for example house and dog, you have the two values 5 and 3. By subtracting the values from each other, you get the difference on how close those values are. So, just return the difference of the length of the two parameters in your ordering function. The first and last element in the list will then be the largest and smallest word (depending on which value you subtract from which).

Answer 4

In Java 8:

import java.util.Arrays;

public class Example {

    public static void main(String[] args) {

        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        String minLengthStr = Arrays.stream(arr)
                                    .min((str1, str2) -> Integer.compare(str1.length(), str2.length()))
                                    .get();

        String maxLengthStr = Arrays.stream(arr)
                                    .max((str1, str2) -> Integer.compare(str1.length(), str2.length()))
                                    .get();

        System.out.println("Longest string is: " + maxLengthStr);
        System.out.println("Shortest string is: " + minLengthStr);
    }
}

Output:

Longest string is: hvordan
Shortest string is: a

Explanation:

The min method in the Stream class takes a Comparator as a parameter. As Comparator is a functional interface we can use a lambda expression as a short hand for implementing it.

So instead of writing:

Comparator<String> lengthComparator = new Comparator<String>() {
    @Override
    public int compare(String str1, String str2) {
        return Integer.compare(str1.length(), str2.length());
    }
};

You can write:

Comparator<String> lengthComparator = (str1, str2) -> Integer.compare(str1.length(), str2.length());

You can use this without streams too:

public class Example {

    public static void main(String[] args) {

        String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        String minLengthStr = arr[0], maxLengthStr = arr[0];

        Comparator<String> lengthComparator = (str1, str2) -> Integer.compare(str1.length(), str2.length());

        for(String str : arr) {
            if(lengthComparator.compare(str, minLengthStr) == -1) {
                minLengthStr = str;
            } else if(lengthComparator.compare(str, maxLengthStr) == 1) {
                maxLengthStr = str;
            }
        }

        System.out.println("Longest string is: " + maxLengthStr);
        System.out.println("Shortest string is: " + minLengthStr);
    }
}

Answer 5

I hope,this will help

public class Test implements Comparator<String>{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

        Set<String> set = new TreeSet<String>(new Test());
        set.add("hei");
        set.add("hvordan");
        set.add("gaar");
        set.add("med");
        set.add("deg");
        set.add("a");

        System.out.println(set);
    }

    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        if(o1.length()>o2.length())
            return 1;
        else if(o1.length()<o2.length())
            return -1;
        else
            return 0;

    }

Answer 6

If you want to play with String, Comparable and compareTo here is an example.

ideone.com

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

public class Test {
    String arr[] = {"hei", "hvordan", "gaar", "det", "med", "deg", "a"};

    /**
     * Use composition.
     */
    class MyComparableString implements Comparable<MyComparableString> {
        String myString;

        MyComparableString(String s) {
            myString = s;
        }

        @Override
        public int compareTo(MyComparableString other) {
            // Compare the lengths of the strings in this and other.
            Integer l1 = myString.length();
            Integer l2 = other.myString.length();
            return l1.compareTo(l2);
        }

        // String representation.
        public String toString() {
            return myString;
        }
    }

    void go() {
        // Convert the String array into a List (Collection) of MyComparableString.
        List<MyComparableString> l = new ArrayList<>();
        for (String s: arr) {
            l.add(new MyComparableString(s));
        }
        // Print longest and shortest.
        System.out.println("Shortest: " + Collections.min(l));
        System.out.println("Longest: " + Collections.max(l));
    }

    public static void main(String[] args) {
        new Test().go();
    }
}