Exemplo demonstra com funcina ordenação de String e char, além do uso de Collator e CollationKey.

gistfile1.txt

import java.text.CollationKey;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.TreeSet;

import static java.lang.System.out;

/**
 * This code shows how works some algorithms to sort array and collections in Java, specifically to String and char.
 * <p>Java 7 uses:</p>
 * <ul>
 *   <li><i>Insertion Sort</i>: used by small arrays of char (<code>Arrays.sort</code>);</li>
 *   <li><i>Quick Sort Dual-Pivot</i>: used by big arrays of char (<code>Arrays.sort</code>);</li>
 *   <li><i>Binary Insertion Sort</i>: used by small arrays of string (<code>Arrays.sort</code>);</li>
 *   <li><i>Tim Sort</i>: (from Python) used by big arrays of string (<code>Arrays.sort</code>);</li>
 *   <li><i>Red-Black Tree</i>: used by <code>TreeSet</code> (hide a TreeMap);</li>
 * </ul>
 * 
 * <p>Here I show how to use <code>Collator<code>, to work with special characters or case insensitive chars.</p>
 * 
 * @author eder.magalhaes
 */
public class OrdenaString {

    public static void main(String[] args) {
        sortArrayChar();
        sortArraySpecialChar();
        
        sortArrayString();
        sortTreeString();
        sortListString();
        
        sortArraySpecialStringWrong();
        sortArraySpecialStringCollator();
        sortListSpecialStringCollator();
        sortTreeSpecialString();
        
        printCollatorValues();
        printStrengthCollatorValues();
        
        sortArrayStringByCollationKeys();
        
        sortArryStringCaseInsensitive();
    }
	
    static void sortArrayChar() {
        String content = "ebdca";
        char[] chars = content.toCharArray();
        
        Arrays.sort(chars);
        
        String sorted = new String(chars);
        out.printf("Ordenando array de char...%n\tAntes:  %s%n\tDepois: %s%n%n",
            content, sorted);
    }
    
    static void sortArraySpecialChar() {
        String content = "abcdeãA";
        char[] chars = content.toCharArray();
        
        Arrays.sort(chars);
        
        String sorted = new String(chars);
        out.printf("Ordenando array de char com caracteres especiais (estranho)...%n\tAntes:  %s%n\tDepois: %s%n%n",
            content, sorted);
    }
    
    static void sortArrayString() {
        String[] content = { "Jose", "Andre", "Claudia", "Bruna" };
        String[] copy =  Arrays.copyOf(content, content.length);
        
        Arrays.sort(content);
        
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy), Arrays.toString(content));
        out.printf("Ordenando array de string...%n%s", toPrint);
    }
    
    static void sortTreeString() {
        Collection<String> content = new TreeSet<>();
        content.add("Jose");
        content.add("Andre");
        content.add("Claudia");
        content.add("Bruna");
        
        out.printf("Coleção TreeSet, mantém strings ordenadas...%n\t%s%n%n", 
            Arrays.toString(content.toArray()));
    }
    
    static void sortListString() {
        List<String> content = new ArrayList<>();
        content.add("Jose");
        content.add("Andre");
        content.add("Claudia");
        content.add("Bruna");
        Collection<String> copy = new ArrayList<>(content);
        
        Collections.sort(content);
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy.toArray()), 
            Arrays.toString(content.toArray()));
        out.printf("Ordenando lista de string...%n%s", toPrint);
    }
    
    static void sortArraySpecialStringWrong() {
        String content[] = { "Andrei", "Andréa", "Cláudia", "Claudio" };
        String[] copy =  Arrays.copyOf(content, content.length);
        
        Arrays.sort(content);
        
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy), Arrays.toString(content));
        out.printf("Ordenando nomes parecidos com acentuação (estranho)...%n%s", toPrint);
    }
    
    static void sortArraySpecialStringCollator() {
        String content[] = { "Andrei", "andréa", "Cláudia", "Claudio" };
        String[] copy =  Arrays.copyOf(content, content.length);
        
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        Arrays.sort(content, colPtBR);
        
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy), Arrays.toString(content));
        out.printf("Ordenando nomes parecidos em array com acentuação (Collator)...%n%s", toPrint);
    }
    
    static void sortListSpecialStringCollator() {
        List<String> content = new ArrayList<>();
        content.add("Andrei");
        content.add("andréa");
        content.add("Cláudia");
        content.add("Claudio");
        List<String> copy = new ArrayList<>(content);
        
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        Collections.sort(content, colPtBR);
        
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy.toArray()), 
            Arrays.toString(content.toArray()));
        out.printf("Ordenando nomes parecidos em lista com acentuação (Collator)...%n%s", toPrint);
    }
    
    static void sortTreeSpecialString() {
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        Collection<String> content = new TreeSet<>(colPtBR);
        content.add("Andrei");
        content.add("Andréa");
        content.add("Cláudia");
        content.add("Claudio");
        
        out.printf("Coleção TreeSet, mantém nomes ordenados usando Collator...%n\t%s%n%n", 
            Arrays.toString(content.toArray()));
    }
	
    static void printCollatorValues() {
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        out.print("Analizando os valores de Collator x Comparable de String\n");
        out.printf("\tcolPtBR.compare(\"Andréa\",\"andrea\") = %s%n", 
            colPtBR.compare("Andréa", "andrea"));
        out.printf("\t\"Andréa\".compareTo(\"andrea\") = %s%n", 
            "Andréa".compareTo("andrea"));
        
        out.printf("%n\tcolPtBR.compare(\"maca\",\"maçã\") = %s%n", 
            colPtBR.compare("maca", "maça"));
        out.printf("\t\"maca\".compareTo(\"maçã\") = %s%n", 
            "maca".compareTo("maçã"));
        
        out.printf("%n\tcolPtBR.compare(\"pedro\",\"PEDRO\") = %s%n", 
            colPtBR.compare("pedro", "PEDRO"));
        out.printf("\t\"pedro\".compareTo(\"PEDRO\") = %s%n%n", 
            "pedro".compareTo("PEDRO"));
    }
    
    static void printStrengthCollatorValues() {
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        colPtBR.setStrength(Collator.PRIMARY);
        
        out.print("Collator ignorando acentuação e minúsculas vs maiúsculas\n");
        out.printf("\tcolPtBR.compare(\"Andréa\",\"andrea\") = %s%n", 
            colPtBR.compare("Andréa", "andrea"));
        
        out.printf("\tcolPtBR.compare(\"maca\",\"maçã\") = %s%n", 
            colPtBR.compare("maca", "maça"));
        
        out.printf("\tcolPtBR.compare(\"pedro\",\"PEDRO\") = %s%n%n", 
            colPtBR.compare("pedro", "PEDRO"));
    }
    
    static void sortArrayStringByCollationKeys() {
        String[] content = { "Andrei", "andréa", "Cláudia", "Claudio" };
        String[] copy = Arrays.copyOf(content, content.length);
        
        CollationKey[] collKeys = new CollationKey[content.length];
        
        Collator colPtBR = Collator.getInstance(new Locale("pt", "BR"));
        for (int i = 0; i < collKeys.length; i++) {
            // guarda a chave da string
            collKeys[i] = colPtBR.getCollationKey(content[i]);
        }
        
        Arrays.sort(collKeys);
        
        //atualiza o array original
        for (int i = 0; i < collKeys.length; i++) {
            content[i] = collKeys[i].getSourceString();
        }
        
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy), Arrays.toString(content));
        out.printf("Ordenando nomes parecidos em array com acentuação via CollectionKey...%n%s", toPrint);
    }
    
    static void sortArryStringCaseInsensitive() {
        String[] content = { "A", "x", "c", "B", "d", "a" };
        String[] copy = Arrays.copyOf(content, content.length);
        
        Arrays.sort(content, String.CASE_INSENSITIVE_ORDER);
        String toPrint = String.format("\tAntes:  %s%n\tDepois: %s%n%n", 
            Arrays.toString(copy), Arrays.toString(content));
        out.printf("Ordenando array de String case insensitive...%n%s", toPrint);
    }

}