Java: trier un tableau de chaînes, dont les chaînes représentent int

J'ai String[] tableau comme

{"3","2","4","10","11","6","5","8","9","7"}

Je veux les trier dans l'ordre numérique, pas dans l'ordre alphabétique.

Si j'utilise

Arrays.sort(myarray);

- Je obtenir

{"10","11","2","3","4","5","6","7","8","9"}

au lieu de

{"2","3","4","5","6","7","8","9","10","11"}

Si vous avez des chaînes de caractères que vous souhaitez utiliser en tant que nombres, pourquoi ne pas les convertir en un type numérique? Ensuite, lorsque vous avez terminé de les utiliser comme des numéros, vous pouvez toujours les convertir en retour à cordes de nouveau... Si vous voulez aller le chemin le plus difficile: créer un Comparateur de<String> pour les fins de la...
Je ne peux pas vous parcourir le tableau et de le convertir en entiers
J'ai lu sur des éléments de comparaison, mais ce est la façon la plus efficace? Compator ou simple conversion?
Lire mon commentaire ci-dessous: il sera toujours plus efficace pour convertir la totalité de l'ensemble d'abord parce que tous les algorithmes de tri prendre plus de comparaisons que la taille de la liste.
Si vous utilisez le tableau de Chaîne de trier par Tableaux.sort (), alors il n'y a aucun moyen pour vous de les trier comme nombre.Parce que vous ne pouvez même pas changer de méthode equals et de toute façon après tout numéro de tableau est le meilleur choix.

InformationsquelleAutor Sefran2 | 2013-03-08

java sorting

3

Je pense que, de loin, la méthode la plus simple et la plus efficace pour convertir le Strings à ints:
```
int[] myIntArray = new int[myarray.length];

for (int i = 0; i < myarray.length; i++) {
    myIntArray[i] = Integer.parseInt(myarray[i]);
}
```
Et puis trier le tableau entier. Si vous en avez vraiment besoin, vous pouvez toujours revenir par la suite:
```
for (int i = 0; i < myIntArray.length; i++) {
    myarray[i] = "" + myIntArray[i];
}
```
Une autre méthode consiste à utiliser le Comparateur interface de dicter exactement comment les éléments sont comparés, mais ce serait sans doute le montant à convertir chaque String de la valeur à un int de toute façon la prise de l'approche ci-dessus beaucoup plus efficace.
- Juste une suggestion: peut-être Integer.toString(myIntArray[i]) pour illustrer le type de conversion plus explicitement que "" + myIntArray[i]
InformationsquelleAutor devrobf
20

Essayer une coutume Comparator, comme ceci:
```
    Arrays.sort(myarray, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return Integer.valueOf(o1).compareTo(Integer.valueOf(o2));
        }
    });
```
Espérons qu'il vous plaira!
- J'aime la concision de cette solution, mais il y a un peu de performances par rapport à la pré-conversion de la matrice car nous convertir une String à un int chaque fois que nous comparer: étant donné que le nombre de comparaisons est toujours plus grande que la taille de la liste, nous faisons plus de conversions que nécessaire. Je ne sais pas si la performance est un problème pour l'OP, mais vaut la peine de garder à l'esprit.
- Vrai, mais je voudrais utilisent souvent un moyen rapide et élégante solution sur une plus soigneusement optimisée pour les performances de l'un jusqu'à ce que je sais il y a une nécessité pour ce dernier.
InformationsquelleAutor vikingsteve
1

De la sortie souhaitée contient l'ordre numérique des correspondants des entiers de vos chaînes. Donc tout simplement vous ne pouvez pas éviter de conversion de chaînes de caractères en nombres entiers. Comme une alternative comparateur de vikingsteve vous pouvez utiliser ceci:
```
Arrays.sort(array, new Comparator<String>() {
    @Override
    public int compare(String str1, String str2) {
        return Integer.parseInt(str1) - Integer.parseInt(str2);
    }
});
```
InformationsquelleAutor Juvanis

U pouvez utiliser le sol-1 si elle ne contient que des nombres dans un format de chaîne.

Solution 1: -

String []arr = {"3","2","4","10","11","6","5","8","9","7"};
        Set<Integer> set = new TreeSet<Integer>();
        Arrays.sort(arr);
        for(String s:arr){
            System.out.print(s+"  ");
            set.add(Integer.parseInt(s));
        }
        System.out.println(set);
        Integer i = new Integer("4f");
        System.out.println(i);

Solution 2:-

String []arr = {"3","2","4","10","11","6","5","8","9","7","jgj","ek"};
        Set<Integer> intSet = new TreeSet<Integer>();
        Set<String> strSet = new TreeSet<String>();
        Arrays.sort(arr);
        for(String s:arr){
            try {
                int i = Integer.parseInt(s);
                intSet.add(i);
            } catch (NumberFormatException e) {
                strSet.add(s);
            }
        }
        List<String> result = new ArrayList<String>();
        for(int val:intSet){
            result.add(val+"");
        }
        result.addAll(strSet);
        System.out.println(result);
    }

Solution 3:-

Écrire un CustomComparator classe et la passer à la méthode sort ().

public class CustomComparator implements Comparator<String>{

    @Override
    public int compare(String s1, String s2) {
        Integer i1=null;
        Integer i2=null;
        try {
            i1 = Integer.parseInt(s1);
        } catch (NumberFormatException e) {
        }

        try {
            i2 = Integer.parseInt(s2);
        } catch (NumberFormatException e) {
        }

        if(i1!=null && i2!=null){
            return i1.compareTo(i2);
        }else{
            return s1.compareTo(s2);
        }
    }

}

public static void main(){
String []arr = {"3","2","4","10","11","6","5","8","9","7","jgj","ek"};
Arrays.sort(arr, new CustomComparator());
        for(String s:arr){
            System.out.print(s+"  ");
        }
}

InformationsquelleAutor sanit

1

Si tous les éléments si votre tableau de chaînes représentant les chiffres, et les chiffres sont toujours positive, alors il existe une manière simple de trier numériquement sans limite à la valeur du nombre.

Ceci est basé sur le fait qu'un nombre avec un plus grand nombre de chiffres est, dans ce cas, toujours supérieur à celui d'un nombre avec un plus petit nombre de chiffres.

Vous d'abord comparer le nombre de chiffres, et ensuite (seulement si le nombre de chiffres est la même) vous comparer la valeur, par ordre alphabétique:
```
Arrays.sort(array,
            Comparator.comparing(String::length).thenComparing(Function.identity()));
```
InformationsquelleAutor Erwin Bolwidt

public class test1 {

public static void main(String[] args) 
{
    String[] str = {"3","2","4","10","11","6","5","8","9","7"};
    int[] a = new int[str.length];
    for(int i=0;i<a.length;i++)
    {
        a[i]=Integer.parseInt(str[i]);
    }
    Arrays.sort(a);
    for(int i=0;i<a.length;i++)
    {
        str[i]=String.valueOf(a[i]);
    }
}

}

InformationsquelleAutor Hussain Akhtar Wahid 'Ghouri'

0

J'ai trouvé cet article sur le tri des chaînes en numérique également le tri pour les chaînes qui peut ou peut ne pas contenir de chiffres:

L'Algorithme Numérique

Il y a un Java exemple de mise en œuvre liées à l'article.
Avec cette classe, vous devriez être en mesure de trier vos tableaux numériquement comme ceci:
```
Arrays.sort(myarray, new AlphanumComparator());
```
InformationsquelleAutor stenix

dans jdk8, vous pouvez écrire ce code avec lambda.

        List<String> list = Arrays.asList("3", "2", "4", "10", "11", "6", "5", "8", "9", "7");
        list.sort(Comparator.comparingInt(Integer::valueOf));
        list.forEach(System.out::println);

surtout comme entrée

String[]{"3.b", "2.c", "4.d", "10.u", "11.a", "6.p", "5.i", "8.t", "9.e", "7.i"}

vous pouvez utiliser des chaînes de caractères.sous-chaîne de choisir la valeur que vous voulez vraiment faire le tri.

comme

 files.sort(Comparator.comparingInt(a -> Integer.valueOf(a.substring(0, a.indexOf(".")))));

InformationsquelleAutor guang y

Vous devez vous connecter pour publier un commentaire.