Java

Appelez-nous au numéro (+212) 616 374 790 ou écrivez-nous à essaddouki@gmail.com

Demander le soutien en ligne de l'un de nos professeurs, à toute heure et où vous voulez, de 8h à minuit (GMT) Détails

Classe Arrays - java.util.Arrays

Une fois que vous aurez compris le pouvoir des tableaux, vous voudrez les utiliser pour stocker toutes sortes d'objets. Il est fréquent que vous souhaitiez effectuer des tâches similaires avec des tableaux différents, par exemple, les remplir avec des valeurs et trier leurs éléments . Java fournit une classe Arrays, qui contient de nombreuses méthodes utiles pour manipuler des tableaux.

MéthodeDescription
static int binarySearch(type[] a, type key)Rechercher dans le tableau spécifié la valeur de key spécifiée à l'aide de l'algorithme de recherche binaire.
static boolean equals(type[] a, type[] a2)Renvoyer true si les deux tableaux du même type spécifiés sont égaux.
static void fill(type[] a, type val)Affecter la valeur spécifiée à chaque élément du tableau spécifié
static void sort(type[] a)Trier le tableau spécifié en ordre croissant
static void sort(type[] a, int fromIndex, int toIndex)Trier la plage spécifiée du tableau en ordre croissant
static void parallelSort(type[] a)Trier le tableau spécifié en ordre croissant à l'aide d'un tri en parallèle.
static void parallelSort(type[] a, int fromIndex, int toIndex)Trier la plage spécifiée du tableau en ordre croissant en utilisant le tri en parallèle
static List asList(type ... a)Renvoyer une liste de taille fixe contient les éléments des tableaux spécifiés.
static type[] copyOf(type[] originalArray, int newLength)Copier le tableau spécifié, en tronquant ou en remplissant avec la valeur par défaut (si nécessaire) afin que la copie ait la longueur spécifiée.
static type[] copyOfRange(type[] originalArray, int fromIndex, int endIndex)Copier la plage spécifiée du tableau spécifié dans un nouveau tableau.
static String toString(type[] originalArray)renvoyer une représentation sous forme de chaîne du contenu du tableau spécifié.

Pour chaque méthode répertoriée dans la colonne de gauche de la table, type correspond à un type de données; une version surchargée de chaque méthode existe pour chaque type de données approprié. Par exemple, il existe une version de la méthode sort() pour trier les tableaux int, double, char, byte, float, long, short et Object.

Les méthodes de la classe Arrays sont des méthodes statiques, ce qui signifie que vous les utilisez avec le nom de la classe sans instancier un objet Arrays. La classe Arrays est située dans le package java.util. Vous pouvez donc utiliser l'instruction import java.util. *; pour y accéder.

Les méthodes parallelSort() de la classe Arrays étaient une nouvelle fonctionnalité de Java 8. Vous utilisez les méthodes de la même façon que vous utilisez les méthodes sort(), mais leurs algorithmes rendent le tri plus efficace si des milliers ou des millions d'objets doivent être triés.

Exemple 1 : binarySearch
                                    import java.util.Arrays;

                                    public class Test {
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                            int[] T2 = { 25, 30, 45, 50, 52, 60 };
                                    
                                            System.out.println(Arrays.binarySearch(T2, 45));
                                        }
                                    }
                            
2
Exemple 2 : equals
                                    import java.util.Arrays;

                                    public class Test {
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                            int[] T2 = { 25, 30, 45, 50, 52, 60 };
                                    
                                            System.out.println(Arrays.equals(T1, T2));
                                        }
                                    }
                            
false
Exemple 3 : toString
                                    import java.util.*;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                    
                                            System.out.println(Arrays.toString(T1));
                                        }
                                    }
                            
[2, 4, 5, 9, 5, 9]
Exemple 4 : fill
                                    import java.util.Arrays;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            int[] T3 = new int[4];
                                            Arrays.fill(T3, 2);
                                            System.out.println(Arrays.toString(T3));
                                        }
                                    }
                            
[2, 2, 2, 2]
Exemple 5 : sort
                                    import java.util.Arrays;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                            Arrays.sort(T1);
                                            System.out.println(Arrays.toString(T1));
                                        }
                                    }
                            
[2, 4, 5, 5, 9, 9]
Exemple 6 : parallelSort
                                    import java.util.Arrays;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                            Arrays.parallelSort(T1);
                                            System.out.println(Arrays.toString(T1));
                                        }
                                    }
                            
[2, 4, 5, 5, 9, 9]
Exemple 7 : asList(type ... a)
                                    import java.util.*;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Integer T1[] = { 10, 20, 30, 40 };
                                            List< Integer> list = Arrays.asList(T1);
                                            System.out.println(list);
                                        }
                                    }
                            
[10, 20, 30, 40]
Exemple 8 : copyOf
                                    import java.util.*;

                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            int[] T1 = { 2, 4, 5, 9, 5, 9 };
                                    
                                            int[] res = Arrays.copyOf(T1, 3);
                                            System.out.println(Arrays.toString(res));
                                    
                                            int[] res2 = Arrays.copyOf(T1, 10);
                                            System.out.println(Arrays.toString(res2));
                                        }
                                    }
                            
[2, 4, 5]
[2, 4, 5, 9, 5, 9, 0, 0, 0, 0]

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :