Inverser un tableau en Java expliqué avec des exemples
Lorsque les programmeurs traitent des tableaux en commençant par le dernier élément, il est toujours plus efficace d'inverser le tableau afin que le premier élément soit placé à la dernière position du tableau. Ensuite, le deuxième élément est à l'avant-dernière position du tableau jusqu'à ce que le dernier élément soit au premier index.
L'une des opérations cruciales de Java consiste à inverser un tableau. Il s'agit d'un défi courant de codage basé sur des tableaux que les programmeurs posent fréquemment au cours des premières séries d'entretiens pour déterminer s'ils peuvent ou non coder. Vous pouvez résoudre ce problème de plusieurs manières, et nous examinerons les plus fréquentes en Java. Parce qu'elle n'est pas centrée sur les types de données, cette approche fonctionne avec n'importe quel type de tableau, y compris les tableaux de chaînes et d'entiers et les tableaux d'objets.
La première approche pour inverser un tableau consiste à le faire de manière brutale, sans nécessiter de structures de données ou de méthodes de bibliothèque supplémentaires. Oui, vous pouvez également inverser le tableau en développant votre fonction qui parcourt le tableau et échange les éléments jusqu'à ce que le tableau soit trié. C'est la meilleure façon d'aborder les entretiens de codage.
Inverser un tableau en Java
En Java, il existe plusieurs façons d'inverser un tableau. Ce sont les suivants :
- Utilisation de la méthode Collections.reverse()
- Inverser un tableau à l'aide d'une boucle For
- Utilisation de la méthode StringBuilder.append()
- Inversion de tableau sur place
- Utiliser l'échange
- Utilisation de ArrayUtils.reverse()
Imprimer un tableau dans l'ordre inverse
Si nous souhaitons imprimer le tableau dans l'ordre inverse sans l'inverser, nous pouvons le faire en utilisant une boucle for qui commence à écrire à partir de la fin du tableau. C'est une excellente solution si nous voulons uniquement imprimer le tableau dans l'ordre inverse sans traitement.
Le tableau est imprimé dans l'ordre inverse dans le logiciel suivant.
import java.util.*;
import java.util.stream.*;
public class Codeunderscored
{
public static void main(String[] args) {
Integer[] intVars = {10,20,30,40,50,60,70,80,90};
// start from the first element when printing the array
System.out.println("The initial Array:");
for(int i=0;i<intVars .length;i++)
System.out.print(intVars[i] + " ");
System.out.println();
//start from the last element when printing the array
System.out.println("The initial Array in a reversed order:");
for(int i=intVars .length-1;i>=0;i--)
System.out.print(intVars[i] + " ");
}
} C'est une alternative viable pour imprimer simplement le tableau. Java a plusieurs méthodes pour inverser les indices des éléments d'un tableau. Les nombreuses manières que nous allons aborder en profondeur dans ce didacticiel sont indiquées ci-dessous.
- Utilisation de la méthode inverse ArrayList
- Boucle avec la méthode habituelle
- Utiliser l'inversion sur place
Utilisation de la méthode Collections.reverse() :ArrayList est utilisé pour inverser un tableau
La méthode "reverse" dans le cadre des collections est utilisée pour inverser un tableau en Java.
Cependant, comme la méthode "reverse" accepte une liste comme argument, vous devez d'abord convertir un tableau en liste. La technique "inverse" est utilisée dans l'application suivante pour inverser un tableau.
import java.util.*;
public class Codeunderscored {
/*function reverses the elements of the array*/
static void reverse(Integer numArray[])
{
Collections.reverse(Arrays.asList(numArray));
System.out.println("The resultant Reversed Array is:" + Arrays.asList(numArray));
}
public static void main(String[] args)
{
Integer [] numArray = {11,13,15,17,19};
System.out.println("The resultant original Array:" + Arrays.asList(numArray));
reverse(numArray);
}
} Nous utilisons la fonction inverse dans ce programme sur un tableau pour le convertir en liste. De plus, nous pouvons inverser un tableau de chaînes de la même manière, comme illustré dans l'exemple suivant.
import java.util.*;
public class Codeunderscored {
/*function reverses the elements of the array*/
static void reverse(String arrVar[])
{
Collections.reverse(Arrays.asList(myArray));
System.out.println("The resultant reversed Array:" + Arrays.asList(arrVar));
}
public static void main(String[] args)
{
String [] arrVar = {"apple", "mangoes", "banana", "lemon", "quava", "peas","passion"};
System.out.println("The resultant original Array:" + Arrays.asList(arrVar));
reverse(arrVar);
}
} Le logiciel ci-dessus crée un tableau de chaînes. Nous inversons le tableau en le transformant en liste et en invoquant la fonction inverse dessus.
Comment inverser un tableau à l'aide d'une boucle For
Une autre méthode pour inverser un tableau consiste à créer un nouveau tableau et à inverser les éléments du tableau précédent. Jetez un oeil à l'exemple suivant.
public class Codeunderscored {
static void ReverseArray(char charArray[], int n)
{
char[] finalArray = new char[n];
int j = n;
for (int i = 0; i < n; i++) {
finalArray[j - 1] = charArray[i];
j = j - 1;
}
System.out.println("The resultant Reversed array: ");
for (int k = 0; k < n; k++) {
System.out.print(finalArray[k] + " ");
}
}
public static void main(String[] args)
{
char [] char_array = {'C','O','D','I','N','G'};
System.out.println(" The initial array is : ");
for (int k = 0; k <charArray .length; k++) {
System.out.print(charArray[k] + " ");
}
System.out.println();
ReverseArray(charArray, charArray.length);
}
} Par exemple, nous avons utilisé un tableau de caractères. Nous inversons les éléments du tableau un par un à l'aide de la fonction inverse, puis affichons le tableau inversé.
Employer la méthode StringBuilder.append()
Si vous travaillez avec un tableau String, vous pouvez utiliser un StringBuilder pour attacher chaque élément du tableau avec une boucle for décrémentant à partir de la longueur du tableau, convertir le StringBuilder en une chaîne et le diviser en un tableau comme quatrième méthode. /P>
// Program for array reversal using the StringBuilder
import java.util.Arrays;
class Codeunderscored {
public static void main (String[] args) {
String[] arr = {"Code", "Underscored"};
StringBuilder reverseArray = new StringBuilder();
for (int i = arr.length; i > 0; i--) {
reverseArray.append(arr[i - 1]).append(" ");
};
String[] finalArray = reverseArray.toString().split(" ");
System.out.println(Arrays.toString(finalArray));
}
} Inversion de tableau sur place
Inverser les éléments d'un tableau sur place sans utiliser de tableau séparé est la troisième manière d'inverser le tableau. Le composant initial du tableau est échangé avec le dernier élément du tableau dans cette fonction. De même, le deuxième élément du tableau est échangé avec l'avant-dernier élément du tableau, et ainsi de suite. Nous aurons le tableau complet inversé à la fin de la traversée du tableau. L'inversion de tableau sur place est illustrée dans le programme suivant.
import java.util.Arrays;
public class Codeunderscored {
/*Swap the first element of the array with the last element, the second element with the second-to-last element, etc.
*/
static void reverseArray(arrVar[], int size)
{
int i, k, temp;
for (i = 0; i < size / 2; i++) {
temp = arrVar[i];
arrVar[i] = arrVar[size - i - 1];
arrVar[size - i - 1] = temp;
}
/*printing the resulting reversed array*/
System.out.println("The resultant reversed Array is: \n" + Arrays.toString(arrVar));
}
public static void main(String[] args)
{
int [] numArray = {21,32,43,54,55,76,87,98,109};
//original array printing
System.out.println("Original Array: \n" + Arrays.toString(numArray));
//function for calling the reverse array
reverseArray(numArray, numArray.length);
}
} Le logiciel génère un tableau inversé en échangeant les éléments du tableau d'origine sans utiliser le second tableau, comme indiqué dans la sortie. Cette méthode est plus efficace car elle utilise moins de mémoire.
Mettre l'échange au travail
Le tableau est entré et imprimé dans la deuxième procédure en utilisant une technique similaire. Cependant, contrairement à la méthode précédente, nous ne construisons pas de nouveau tableau. Au lieu de cela, nous inversons l'ordre d'origine du tableau.
Les éléments du tableau sont permutés dans cette procédure. Le premier et le dernier élément sont inversés. Le deuxième élément remplace l'avant-dernier élément, et ainsi de suite. Prenons, par exemple, le tableau [1, 2, 3,…., n-2, n-1, n]. Nous changeons 1 en n, 2 en n-1, 3 en n-2, et ainsi de suite.
// Program for reversing the array in a fewer number of swaps
public class arrayReverse {
// function swaps the array's first element with last
// element, second element with last second element and
// so on
static void reverse(int numArray[], int n)
{
int j, w, x;
for (j = 0; j < n / 2; j++) {
x = numArray[j];
numArray[j] = numArray[n - j - 1];
numArray[n - j - 1] = x;
}
// printing the reversed array
System.out.println(" The resultant reversed array is: \n");
for (w = 0; w < n; w++) {
System.out.println(numArray[w]);
}
}
public static void main(String[] args)
{
int[] arrVars = { 50, 70, 80, 90, 100 };
reverse(arrVars, arrVars.length);
}
} Utiliser ArrayUtils.reverse()
Apache Commons est une bibliothèque open source contenant de nombreuses bibliothèques d'utilitaires nécessaires au développement de logiciels Java. Cette bibliothèque devrait être incluse par défaut dans les projets Java pour compléter le JDK. Apache commons-lang fournit une classe ArrayUtils avec des méthodes reverse() surchargées pour inverser les tableaux int, float ou object en Java. Cette méthode inverse également le tableau donné en place plutôt que d'en renvoyer un nouveau.
import java.util.Arrays;
import org.apache.commons.lang3.ArrayUtils;
/**
* Program for reversing an array in Java using Apache Commons Lang ArrayUtils
* class.
*
*/
public class Pattern {
public static void main(String args[]) {
String[] compVars = {"HP", "DELL", "IBM", "Lenovo"};
System.out.println(" Original Array before reversal: "
+ Arrays.toString(compVars));
ArrayUtils.reverse(compVars);
System.out.println("Resultant Array after reversal: "
+ Arrays.toString(compVars));
}
} Comme vous pouvez le voir, nous avons réussi à inverser le tableau avec une seule ligne. Vous devez inclure commons-lang3-3.4.jar dans le chemin de classe de votre application pour utiliser la classe ArrayUtils d'Apache commons-lang. Vous pouvez utiliser Maven à la place en ayant la dépendance suivante dans votre fichier pom.xml.
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency> Exemple 1 :programme d'inversion de tableau à l'aide de collections Java
import java.util.*;
public class reversingArray {
// function responsible for reversing the elements of the array
static void reverse(Integer numArr[])
{
Collections.reverse(Arrays.asList(numArr));
System.out.println(Arrays.asList(numArr));
}
public static void main(String[] args)
{
Integer [] numArr = {60, 70, 80, 90, 100};
reverse(numArr);
}
}
Exemple 2 :Programme qui inverse un tableau
public class reverseArray {
// function responsible for reversing an array and storing it in another array
static void reverse(int arrVar[], int n)
{
int[] bArr = new int[n];
int j = n;
for (int i = 0; i < n; i++) {
bArr[j - 1] = arrVar[i];
j = j - 1;
}
// reversed array printing
System.out.println("The resultant reversed array is: \n");
for (int x = 0; x < n; x++) {
System.out.println(bArr[x]);
}
}
public static void main(String[] args)
{
int [] arr = {10, 20, 30, 40, 50};
reverse(arr, arr.length);
}
} Conclusion
Les tableaux sont une technique de codage courante pour stocker plusieurs valeurs du même type dans une seule variable. Il existe diverses raisons pour lesquelles un programmeur peut vouloir inverser un tableau. Lorsque la logique d'un problème nécessite de partir de la dernière entrée, il peut être nécessaire d'inverser un tableau.
Cet article a examiné comment inverser un tableau en Java en utilisant plusieurs techniques. Bien que nous ayons utilisé des données entières à des fins de démonstration, les mêmes méthodes sont utilisées pour inverser le tableau avec toute autre donnée, qu'elle soit primitive ou non.
Pour des routines spécifiques en Java, les types de tableaux les plus primitifs - int, long, string et double - peuvent être inversés. ArrayUtils est une classe d'Apache commons-lang, une bibliothèque open source gérée par l'Apache Software Foundation. Jouant avec l'objet et les tableaux de base en Java, cette classe intrigante est utilisée en conjonction avec la classe java.util.Arrays. L'API inclut des méthodes surchargées pour inverser de nombreux types de tableaux Java, notamment les tableaux int, long, double, float et object.
