J'ai un programme dans lequel l'utilisateur entre une liste de noms. J'ai un boîtier de commutation allant à une fonction pour laquelle je voudrais que les noms soient imprimés 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));
et
Java.util.Collections.sort(hotel);
Bizarre, votre 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 exécuté ce code en utilisant "Java Test Bobby Joe Angel" et voici la sortie:
$ Java Test Bobby Joe Angel
Angel
Bobby
Joe
La première chose que vous avez essayée semble bien fonctionner. Voici un exemple de programme.
Appuyez sur le bouton "Démarrer" en haut de cette page pour l'exécuter 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));
}
}
Vous pouvez simplement utiliser Arrays#sort()
, cela 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]);
}
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));
}
}
Par ordre alphabétique, je suppose que l'ordre est: A | a <B | b <C | c ... J'espère que c'est ce que @Nick cherche (ou était) à la recherche de la réponse ci-dessus.
Je suggérerais d’avoir une méthode de comparaison d’implémentation de classe de Comparator-interface comme:
public int compare(Object o1, Object o2) {
return o1.toString().compareToIgnoreCase(o2.toString());
}
et à partir de la méthode d'appel, invoquez la méthode Arrays.sort avec un comparateur personnalisé sous la forme:
Arrays.sort(inputArray, customComparator);
Résultats observés: Input Tableau: "Vani", "Kali", "Mohan", "Soni", "kuldeep", "Arun"
le résultat (ordre alphabétique) est: Arun, Kali, Kuldeep, Mohan, Soni, Vani
La sortie (ordre naturel en exécutant Arrays.sort (inputArray) est: Arun, Kali, Mohan, Soni, Vani, kuldeep
Ainsi, en cas d’ordre naturel, [Vani <kuldeep] n’est pas ce qui est à mon sens compris dans l’ordre alphabétique.
pour plus de compréhension de l'ordre naturel et alphabétique/lexical, visitez discussion ici
Java.util.Collections.sort (listOfCountryNames, Collator.getInstance ());
Méthode CompareTo()
: les deux chaînes sont comparées en fonction des valeurs de caractère Unicode.
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");
}
}
}
**//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]);
}
}
}**
Arrays.sort (stringArray); Ceci trie le tableau de chaînes en fonction des valeurs de caractères Unicode. Toutes les chaînes contenant des caractères majuscules au début de la chaîne se trouveront en haut de la liste triée, suivies par ordre alphabétique, suivies de toutes les chaînes comportant des minuscules. Par conséquent, si le tableau contient des chaînes commençant par des caractères majuscules et minuscules, le tableau trié ne renverra pas une liste alphabétique sans distinction de casse.
String[] strArray = { "Carol", "bob", "Alice" };
Arrays.sort(strList);
System.out.println(Arrays.toString(hotel));
La sortie est: Alice, Carol, Bob,
Si vous souhaitez que les chaînes soient triées sans tenir compte de la casse, vous aurez besoin d'un deuxième argument, un comparateur, pour Arrays.sort (). Un tel comparateur a déjà été écrit pour nous et est accessible en tant que statique dans la classe String nommée CASE_INSENSITIVE_ORDER.
String[] strArray = { "Carol", "bob", "Alice" };
Arrays.sort(stringArray, String.CASE_INSENSITIVE_ORDER);
System.out.println(Arrays.toString(strArray ));
La sortie est: Alice, Bob, Carol
Vous pouvez utiliser la méthode Arrays.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, frederick, peter, taylor]
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;
}