The best way to find out the biggest length

Question

I have fours variables that call different methods:

public String[] longestSide(){
     ArrayList<T> western = getWestern();
     ArrayList<T> eastern = getEastern();
     ArrayList<T> northern = getNorthern();
     ArrayList<T> southern = getSouthern();

   return //theLongestOne??
}

Instead of writing a bunch of if-else statements, what is the shortcut to find out which of the arraylists has the longest length and return it? Thanks!

Answer 1

return Collections.max(Arrays.asList(western, eastern, northern, southern),
                       (a, b) -> Integer.compare(a.length, b.length));

If not on Java 8 yet, the same code can be written as

return Collections.max(Arrays.asList(western, eastern, northern, southern),
                       new Comparator<String[]> {
                           @Override
                           public int compare(String[] a, String[] b) {
                               return Integer.compare(a.length, b.length));
                           }
                        });

If what you have is in fact 4 List<String>, and not 4 arrays as in the original question, then it's even simpler:

return Collections.max(Arrays.asList(western, eastern, northern, southern),
                       Comparator.comparing(List::size));

which is equivalent to

return Collections.max(Arrays.asList(western, eastern, northern, southern),
                       new Comparator<List<String>> {
                           @Override
                           public int compare(List<String> a, List<String> b) {
                               return Integer.compare(a.size(), b.size());
                           }
                        });

Answer 2

String maxLength = Math.max(Math.max(western.length, eastern.length), Math.max(southern.length, northern.length));
String[] longest = 
    western.length == maxLength ? western :
    eastern.length == maxLength ? eastern :
    southern.length == maxLength ? southern :
    northern;

Answer 3

Define a method as follows:

public Sting[] longestOf(String[] a, String[] b){
 if(a.length>b.length) {
   return a;
 }
 return b;
}

Now, you can do the following in your longestSide() method:

return longestOf(longestOf(western, eastern), longestOf(northern, southern));

Answer 4

return Collections.max(Arrays.asList(getWestern(), getEastern(), getNorthern(),  getSouthern()), new Comparator<String[]>() {
    @Override
    public int compare(String[] first, String[] second) {
         return first.length - second.length;
    }
});

Answer 5

You can do it in another way.There can be some compilation problem, but the general idea is clear:

private List<T> longest;

// Decorator method, which will return array list, but will also calculate required longest direction.
public <T> List<T> calculateAndGet(List<T> list) {

     if (Objects.isNull(longest) || longest.size() < list.size()) {
           longest = list.size();
     }

     return list;
}

public String[] longestSide(){
     List<T> western = calculateAndGet(getWestern());
     List<T> eastern = calculateAndGet(getEastern());
     List<T> northern = calculateAndGet(getNorthern());
     List<T> southern = calculateAndGet(getSouthern());

   return longest.toArray(new String[longest.size()]);
}

I also changed ArrayList to List. Is there any specific logic not to use "Coding to interfaces" principle?

Answer 6

Implementing as suggested by Shai in a comment:

public String[] longestSide(){
    String[] western = getWestern();
    String[] eastern = getEastern();
    String[] northern = getNorthern();
    String[] southern = getSouthern();

    String[] longest = null;
    for (String[] a : new String[][] {western,eastern,northern,southern})
        if (longest == null || a.length > longest.length)
            longest = a;
    return longest;
}

Or using a helper method for a List (or other Collection) as indicated by updated question:

@SafeVarargs
public static <L extends Collection<?>> L longestOf(L ... lists) {
    L longest = lists[0];
    for (int i = 1; i < lists.length; i++)
        if (lists[i].size() > longest.size())
            longest = lists[i];
    return longest;
}

Use like this:

return longestOf(western, eastern, northern, southern);