If I remember correctly, the Arrays.sort(...) takes a Comparator<> that it will use to do the sorting. You can provide an implementation of it that looks at the extension part of the string.

You can implement a custom Comparator of Strings. Make it sort them by the substring after the last index of '.'. Then pass in the comparator and your array into

Arrays.sort(stringArray, yourComparator);

//  An implementation of the compare method
public int compare(String o1, String o2) {
    return o1.substring(o1.lastIndexOf('.')).compareTo(o2.substring(o2.lastIndexOf('.'));
}

Create a Comparator and compare the string extensions. Take a look at the following

http://java.sun.com/j2se/1.4.2/docs/api/java/util/Comparator.html

Then pass in your List of strings to Arrays.sort(List, Comparator)

Create your own Comparator that treats the strings as filenames and compares them based on the extensions. Then use Arrays.sort with the Comparator argument.

I think the simplest thing you can do that also works when the filenname does not have a "." is to just reverse the names and compare them.

Arrays.sort(ary, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        String r1 = new StringBuffer(o1).reverse().toString();
        String r2 = new StringBuffer(o2).reverse().toString();
        return r1.compareTo(r2);
    }
});

Its a shame that java's string does not even have a reverse().

Comparators are often hard to get exactly right, and the comparison key has to be generated for every comparison which for most sorting algorithms mean O(n log n). Another approach is to create (key, value) pairs for each item you need to sort, put them in a TreeMap, and then ask for the values as these are sorted according to the key.

For instance

import java.util.Arrays;
import java.util.TreeMap;

public class Bar {

    public static void main(String[] args) {
    	TreeMap<String, String> m2 = new TreeMap<String, String>();
    	for (String string : Arrays.asList(new String[] { "#3", "#2", "#1" })) {
    		String key = string.substring(string.length() - 1);
    		String value = string;
    		m2.put(key, value);
    	}
    	System.out.println(m2.values());
    }
}

prints out

[#1, #2, #3]

You should easily be able to adapt the key calculation to your problem.

This only calculates the key once per entry, hence O(n) - (but the sort is still O(n log n)). If the key calculation is expensive or n is large this might be quite measurable.