Liste un Tableau de Chaînes de caractères dans l'ordre alphabétique

J'ai un programme qui a les entrées de l'utilisateur une liste de noms. J'ai un interrupteur cas aller à une fonction à laquelle je voudrais avoir les noms imprimer dans l'ordre alphabétique.

public static void orderedGuests(String[] hotel)
{
  //??
}

J'ai essayé les deux

Arrays.sort(hotel);
System.out.println(Arrays.toString(hotel));

java.util.Collections.sort(hotel);

Ce qui n'a pas de travail au sujet de ces solutions?
Poste le code complet. Avec la commande que vous êtes en train de faire tout.

OriginalL'auteur Nick Mico | 2013-02-18

Bizarre, ton code semble fonctionner pour moi:

import java.util.Arrays;

public class Test
{
    public static void main(String[] args)
    {
        //args is the list of guests
        Arrays.sort(args);
        for(int i = 0; i < args.length; i++)
            System.out.println(args[i]);
    }
}

J'ai couru ce code à l'aide de "java Test Bobby Joe Ange" et voici le résultat:

$ java Test Bobby Joe Angel
Angel
Bobby
Joe

OriginalL'auteur Vineet Kosaraju

La première chose que vous avez essayé semble bien fonctionner. Voici un exemple de programme.

Appuyez sur le bouton "Démarrer" en haut de cette page de le lancer pour voir la sortie vous-même.

import java.util.Arrays;

public class Foo{
    public static void main(String[] args) {
        String [] stringArray = {"ab", "aB", "c", "0", "2", "1Ad", "a10"};
        orderedGuests(stringArray);
    }

    public static void orderedGuests(String[] hotel)
    {
        Arrays.sort(hotel);
        System.out.println(Arrays.toString(hotel));
    }
}

OriginalL'auteur zevdg

Vous pouvez simplement utiliser Arrays#sort(), il fonctionne parfaitement.
Voir cet exemple :

String [] a = {"English","German","Italian","Korean","Blablablabla.."};
//before sort
for(int i = 0;i<a.length;i++)
{
  System.out.println(a[i]);
}
Arrays.sort(a);
System.out.println("After sort :");
for(int i = 0;i<a.length;i++)
{
  System.out.println(a[i]);
}

OriginalL'auteur Azad

Voici le code qui fonctionne:

import java.util.Arrays;
import java.util.Collections;

public class Test
{
    public static void main(String[] args)
    {
        orderedGuests1(new String[] { "c", "a", "b" });
        orderedGuests2(new String[] { "c", "a", "b" });
    }

    public static void orderedGuests1(String[] hotel)
    {
        Arrays.sort(hotel);
        System.out.println(Arrays.toString(hotel));
    }

    public static void orderedGuests2(String[] hotel)
    {
        Collections.sort(Arrays.asList(hotel));
        System.out.println(Arrays.toString(hotel));
    }

}

OriginalL'auteur Amit

1

java.util.Les Collections.de tri(listOfCountryNames, Collateur.getInstance());

OriginalL'auteur Shan Arshad
1

Par ordre alphabétique ordre je suppose que la commande soit : A|a < B|b < C|c...
L'espoir c'est ce que @Nick est(ou était) la recherche et la réponse suit l'hypothèse ci-dessus.

Je suggère d'avoir une classe implémente la méthode de comparaison de Comparateur-interface :
```
public int compare(Object o1, Object o2) {
    return o1.toString().compareToIgnoreCase(o2.toString());
}
```
et de la méthode appelante invoque les Tableaux.méthode de tri personnalisé Comparateur :
```
Arrays.sort(inputArray, customComparator);
```
Résultats observés:
Tableau d'entrée : "Vani","Kali", "A","I","kuldeep","Arun"

de sortie(dans l'ordre Alphabétique):
Arun, Kali, kuldeep, Mohan, Soni, Vani

De sortie(Naturel de la commande par l'exécution de Tableaux.de tri(inputArray) est :
Arun, Kali, Mohan, Soni, Vani, kuldeep

Ainsi, dans le cas de l'ordre naturel, [Vani < kuldeep] qui à ma compréhension du alphabétique ordre n'est pas la chose désirée.

pour plus de compréhension de naturel et alphabétique/ordre lexical visite la discussion ici

OriginalL'auteur Vinayak

CompareTo() méthode: Les deux chaînes sont comparées en fonction du caractère Unicode valeurs.

import java.util.*;

public class Test {

int n,i,temp;
String names[n];

public static void main(String[] args) {
String names[5] = {"Brian","Joshua","Louis","David","Marcus"};

for(i=0;i<5;i++){
    for(j=i+1;i<n;j++){
        if(names[i].CompareTo(names[j]>0) {
             temp=names[i];
             names[i]=names[j];
             names[j]=temp;
         } else
             System.out.println("Alphabetically Ordered");                               
         }
     }                              
}

OriginalL'auteur Joshua Poddoku

**//With the help of this code u not just sort the arrays in alphabetical order but also can take string from user or console or keyboard

import java.util.Scanner;
import java.util.Arrays;
public class ReadName
{
final static int ARRAY_ELEMENTS = 3;
public static void main(String[] args)
{
String[] theNames = new String[5];
Scanner keyboard = new Scanner(System.in);
System.out.println("Enter the names: ");
for (int i=0;i<theNames.length ;i++ )
{           
theNames[i] = keyboard.nextLine();
}
System.out.println("**********************");
Arrays.sort(theNames);
for (int i=0;i<theNames.length ;i++ )
{
System.out.println("Name are " + theNames[i]);
}
}
}**

OriginalL'auteur Hrishi D Developer

0

Tableaux.de tri(stringArray);
Il trie le tableau de chaîne basée sur les caractères Unicode valeurs. Toutes les chaînes qui contiennent des caractères majuscules au début de la chaîne sera en haut de la liste triée par ordre alphabétique, suivi par toutes les chaînes de caractères avec des caractères en minuscules.
Ainsi, si le tableau contient des chaînes de caractères commençant par deux caractères en majuscules et en minuscules, le tableau trié ne serait pas de retour a la casse ordre alphabétique liste
```
String[] strArray = { "Carol", "bob", "Alice" };
Arrays.sort(strList);
System.out.println(Arrays.toString(hotel));
```
De sortie est : Alice, Carol, bob,

Si vous avez besoin de Chaînes pour être triés et sans distinction de cas, vous aurez besoin d'un second argument, un Comparateur, pour les Tableaux.sort(). Une telle comparaison a déjà été écrit pour nous et peut être consulté comme statique sur la classe String nommé CASE_INSENSITIVE_ORDER.
```
String[] strArray = { "Carol", "bob", "Alice" };
Arrays.sort(stringArray, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strArray ));
```
De sortie est : Alice, bob, Carol

OriginalL'auteur Fergal Fitz

Vous pouvez utiliser des Tableaux.méthode sort (). Voici l'exemple,

import java.util.Arrays;

public class Test 
{
    public static void main(String[] args) 
    {
        String arrString[] = { "peter", "taylor", "brooke", "frederick", "cameron" };
        orderedGuests(arrString);
    }

    public static void orderedGuests(String[] hotel)
    {
        Arrays.sort(hotel);
        System.out.println(Arrays.toString(hotel));
    }
}

Sortie

[brooke, cameron, frédéric, pierre, taylor]

OriginalL'auteur Shiva

 public static String[] textSort(String[] words) {
    for (int i = 0; i < words.length; i++) {
        for (int j = i + 1; j < words.length; j++) {
            if (words[i].compareTo(words[j]) > 0) {
                String temp = words[i];
                words[i] = words[j];
                words[j] = temp;
            }
        }
    }

    return words;
}

OriginalL'auteur MOSDEV

Vous devez vous connecter pour publier un commentaire.