-1
votes

Comment trier les chaînes en Java, l'ordre devrait afficher d'abord les chaînes de Capitol

besoin de trier les chaînes en Java dans une casse sensible à la casse, mais les lettres majuscules devraient afficher en premier.

ce que j'ai essayé: PRE>

[AAA,AAA,aaa,aaa,BBB,CCC,ccc]


7 commentaires

@PaullMarchand a mis à jour ma question. besoin de trier les chaînes, pas de char.


Et si elle a des chaînes telles que aaa ou aaa ou aaa ?


Voir ma réponse mise à jour


@ User7 puis AAA, AAA, AAA devrait être la commande.


Votre question n'est toujours pas claire. Voulez-vous énumérer la chaîne qui a la plupart des caractères majuscules consécutifs (comparer des caractères à partir de débutants) en premier? Ensuite, qu'en est-il des chaînes avec différentes longueurs comme [ aa , aaa ]


Consultez mon édition récente et si cela répond à vos besoins.


@ user7 ce travail est pour ma question. l.sort ((O1, O2) -> {INT Comparignorecaseresult = o1.comparetOignorecase (O2); Si (Comparignorecaseresult! = 0) {Retour Comparignorecaseresult;} retour o1.compareto (O2);});


4 Réponses :


2
votes

Vous pouvez ajouter un deuxième comparateur pour décider de la commande après avoir comparé d'ignorer le boîtier. Les deuxième ordonnances de comparaison basées sur le boîtier des caractères.

 l.sort(String.CASE_INSENSITIVE_ORDER
        .thenComparing((a, b) -> {
            //String a and b are equal when compared ignoring case (and hence same length)
            for (int i = 0; i < a.length(); i++) {
                if (Character.isUpperCase(a.charAt(i)) && Character.isLowerCase(b.charAt(i))) {
                    return -1;
                } else if (Character.isLowerCase(a.charAt(i)) && Character.isUpperCase(b.charAt(i))) {
                    return 1;
                }
            }
            return 0;
        }));


0 commentaires

0
votes
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortStrings {

    public static void main(String[] args) {
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if(o1 == null) {
                    return 1;
                }
                if(o2 == null) {
                    return -1;
                }
                int result = o1.compareToIgnoreCase(o2);
                if(result != 0) {
                    return result;
                }
                return o1.compareTo(o2);
            }
        };

        List<String> list = Arrays.asList("A","a","A","a", "B", "c","C");
        Collections.sort(list, comparator);
        System.out.println(list);
        // [A, A, a, a, B, C, c]

        List<String> list2 = Arrays.asList("Ab","a","AB", "A", "AbB", "a","B","c","C");
        Collections.sort(list2, comparator);
        System.out.println(list2);
        // compare length first
        // [A, a, a, AB, Ab, AbB, B, C, c]

        List<String> list3 = Arrays.asList("aaa","AAA","AAA","aaa","BBB","ccc","CCC");
        Collections.sort(list3, comparator);
        System.out.println(list3);
        // [AAA, AAA, aaa, aaa, BBB, CCC, ccc]
    }
}

0 commentaires

0
votes

Le code suivant vous aide à trier la chaîne dans Case_insenitive_order. Ici, vous avez besoin de deux fois de tri pour la liste. XXX


3 commentaires

@Mohanreddy ma réponse trie les cordes pas de caractère.


Merci, votre réponse travaillant comme prévu. Mais pourquoi avoir besoin d'appeler 2 fois genre ()? toute explication?


Sur le premier tri avec case_senitive_order de sorte que tous les mots majuscules sont arrivés en premier et les mots minuscules sont en dernier. Comme [A, A, B, C, A, A, C] lorsque nous effectuons un deuxième tri avec case_insenitive_order , il ne dispose que de mots minuscules. comme [a, a, a, a, b, c, c]



1
votes

Ceci est un tri personnalisé, pas un tri sensible à la casse. Parce que dans le tri en cas de tri, toutes les lettres majuscules se tiendront avant de petites lettres. Par conséquent, le résultat sera xxx pré>

pour réaliser votre tri personnalisé, vous devez utiliser un comparateur personnalisé, comme suit P>

p>

import org.junit.Test;

import java.util.Arrays;
import java.util.List;

public class SortCapitalFirst {

    @Test
    public void runTest(){
        List<String> l = Arrays.asList("aaa","AAA","AAA","aaa","BBB","ccc","CCC");
        l.sort((o1, o2) -> {
            int compareIgnoreCaseResult = o1.compareToIgnoreCase(o2);

            if (compareIgnoreCaseResult != 0){
                return compareIgnoreCaseResult;
            }

            return o1.compareTo(o2);
        });
        System.out.println(l);
    }
}

 


1 commentaires

@anhqan, je n'ai pas mentionné "Tri sensible à la casse", j'ai besoin de trier comme prévu dans la question ci-dessus.