Tableau de chaînes en Java expliqué avec des exemples
Cet article Java String Array explique comment déclarer, initialiser et créer des tableaux de chaînes en Java et diverses conversions pouvant être effectuées sur String Array. En Java, les tableaux sont une structure de données commune pour stocker de nombreux types de données, allant de l'élémentaire à défini par l'utilisateur. Nous n'aborderons pas les principes fondamentaux des tableaux et certaines des opérations les plus courantes qui y sont effectuées.
Qu'est-ce qu'un tableau de chaînes en Java ?
Un tableau avec des chaînes comme éléments est possible. Par conséquent, un tableau de chaînes peut être défini comme un tableau contenant de nombreuses chaînes ou valeurs de chaîne. En Java, un tableau de chaînes est l'une des structures les plus utilisées. N'oubliez pas que la méthode "main" de Java prend un tableau de chaînes en entrée.
Un tableau de chaînes est une collection de choses. Chaque élément est une chaîne. Comme vous le savez bien, une String est un objet en Java. Sur un tableau String, vous pouvez effectuer toutes les opérations telles que le tri, l'ajout d'un élément, la jointure, la division, la recherche, etc.
Dans cet article, nous allons passer en revue le tableau de chaînes en Java en profondeur et les nombreuses opérations et conversions qui peuvent être effectuées.
Déclaration d'un tableau de chaînes
Les deux principales façons de déclarer un String Array en Java incluent :avec ou sans spécification de taille. Les deux méthodes pour déclarer un String Array sont listées ci-dessous.
String[] arrayVar ; // declaring a string array without size String[] arrayVar = new String[5];// Declaration of a string array with size
Un String Array est déclaré comme une variable régulière sans taille dans la première déclaration. Il convient de noter que vous devrez créer ce tableau avec de nouveaux avant de l'utiliser.
Un String Array est déclaré et instancié dans la deuxième déclaration à l'aide de new. Un tableau String à cinq éléments nommé ‘arrayVar’ est déclaré ici. Étant donné que le tableau n'est pas initialisé, si vous imprimez directement les éléments de ce tableau, vous verrez toutes les valeurs nulles. Créons un programme qui explique comment déclarer un String Array.
public class Codeunderscored
{
public static void main(String[] args) {
String[] arrayVarOne ; // declaring a string array without size
String[] arrayVarTwo = new String[5];// Declaration of a string array with size
//System.out.println(myarray[0]); //variable arrayVar might not have been initialized
//show second array elements
System.out.print(arrayVarTwo[0] + " " +arrayVarTwo[1]+ " " + arrayVarTwo[2]+ " " +
arrayVarTwo[3]+ " " +arrayVarTwo[4]);
}
} Le programme ci-dessus illustre deux méthodes pour déclarer un tableau de chaînes. La déclaration initiale, comme indiqué précédemment, est dépourvue de taille et d'instanciation. Par conséquent, vous devrez essayer quelque chose avec "nouveau" pour créer ce tableau avant de l'utiliser. Le tableau arrayVarOne est utilisé sans instanciation dans le programme donné, ce qui entraîne une erreur de compilation (instruction commentée).
La taille fait l'objet de la deuxième déclaration. Par conséquent, lorsque les valeurs des éléments individuels du tableau String sont écrites, elles sont nulles car le tableau n'a pas été rempli.
Configuration d'un tableau de chaînes
Après avoir déclaré le String Array, vous devrez le remplir avec des données. Sinon, des valeurs nulles sont attribuées aux éléments String en tant que valeurs par défaut. Par conséquent, après avoir déclaré le tableau, nous procédons à son initialisation.
Un tableau String peut être initialisé en ligne avec la déclaration ou après avoir été déclaré. Voyons d'abord comment initialiser un tableau String en ligne.
String[] numArrayVar = {"one", "two", "three"};
String[] strArrayVar = new String[] {"one", "two", "three", "four"}; Les initialisations dans le String Array ci-dessus sont des initialisations en ligne. Le String Array est déclaré et initialisé en même temps. Vous pouvez également utiliser le code suivant pour créer un String Array :
String[] strArrayVar = new String[5]; strArrayVar[0] = "one"; strArrayVar[1] = "two"; strArrayVar[2] = "three"; strArrayVar[3] = "four"; strArrayVar[4] = "five";
Le String Array est déclaré en premier dans ce cas. Les éléments individuels reçoivent ensuite des valeurs dans la ligne suivante. Après avoir initialisé le String Array, vous pouvez l'utiliser de manière générale dans votre programme.
Longueur/taille du tableau de chaînes
Vous savez que les tableaux ont une propriété de longueur qui peut être utilisée pour déterminer la taille du tableau. C'est également vrai pour les tableaux de chaînes. De plus, la taille d'un tableau est déterminée par la taille ou la longueur du tableau (n'importe quel tableau). Par conséquent, vous pouvez utiliser l'instruction suivante pour trouver la longueur du tableau nommé arrayVar.
int len = arrayVar.length;
// Let's write a program to display the length of a String Array.
public class Codeunderscored
{
public static void main(String[] args) {
//declare and initialize a string array
String[] numArrayVar = {"one","two", "three", "four", "five"};
int len = numArrayVar.length; //get the array length
//showing the length
System.out.println("Length of numArrayVar{\"one\",\"two\", \"three\", \"four\", \"five\"}:" + len);
}
} La propriété length est pratique lorsque vous devez parcourir un tableau de chaînes pour le traiter ou l'imprimer.
Itérer dans un tableau de chaînes et l'afficher
Nous avons passé en revue les propriétés de déclaration, d'initialisation et de longueur d'un tableau de chaînes jusqu'à présent ; il est maintenant temps de passer en revue chaque élément du tableau et d'imprimer les éléments String Array. Vous pouvez parcourir un tableau de chaînes à l'aide de la boucle for et de la boucle for améliorée, comme n'importe quel autre tableau. Une méthode Java ci-dessous montre comment parcourir/itérer le tableau et générer ses éléments à l'aide d'une boucle for a améliorée.
public class Codeunderscored
{
public static void main(String[] args) {
//declaration and String Array initialization
String[] numArrayVar = {"one","two", "three", "four", "five"};
System.out.println("using for loop to show elements in the String Array:");
// for loop for iterating over the given string array
for(int i=0; i<numArrayVar.length;i++)
System.out.print(numArrayVar[i] + " ");
System.out.println("\n");
System.out.println("using enhanced for loop to display elements in the String Array:");
//iterating over the string array using enhanced for loop
for(String var:numArrayVar)
System.out.print(var + " ");
}
} La boucle for habituelle et la boucle for avancée sont utilisées pour parcourir le tableau de chaînes dans l'application ci-dessus. Il convient de noter qu'il n'est pas nécessaire de déclarer une limite ou une condition de fin dans le cas d'une boucle for a améliorée. Lors de l'utilisation de la boucle " for ", vous devez définir les conditions de début et de fin.
Ajouter au tableau de chaînes
Comme les autres structures de données, les tableaux de chaînes peuvent avoir des éléments ajoutés. Cette section examine les différentes techniques pour ajouter un élément au tableau de chaînes.
Utiliser la pré-allocation
La pré-allocation est une technique d'allocation des ressources à l'avance. Vous générez un tableau avec une taille plus grande en utilisant cette méthode. Par exemple, si vous devez stocker 5 éléments dans un tableau, vous construirez un tableau de 10 éléments. Ce dernier permet simplement d'ajouter de nouveaux éléments à la fin du tableau.
Voici un exemple de la façon d'ajouter un nouvel élément au tableau pré-alloué.
import java.util.*;
public class Codeunderscored
{
public static void main(String[] args) {
String[] langArray = new String[7];
// initial array values
langArray[0] = "Python";
langArray[1] = "Java";
langArray[2] = "JavaScript";
langArray[2] = "C++";
System.out.println("The initial Array is:" + Arrays.toString(langArray));
countOfItems = 4;
// try adding new values to the array's end
String newLang = "Go";
colorsArray[countOfItems++] = newLang;
System.out.println("Array after adding one element:" +
Arrays.toString(langArray));
}
} Il convient de noter que l'espace vide du tableau est défini sur Null. L'inconvénient de cette stratégie est qu'elle gaspille de l'espace car vous pouvez avoir un vaste tableau qui n'est pas utilisé.
Utilisation d'un nouveau tableau
Cette méthode crée un nouveau tableau plus étendu que le tableau d'origine afin que le nouvel élément puisse être pris en charge. Après avoir généré le nouveau tableau, tous les éléments du tableau précédent y sont transférés, puis le nouvel élément est ajouté à la fin. Voici un exemple de programme qui utilise le nouveau tableau pour ajouter un élément.
importjava.util.*;
public class Codeunderscored
{
public static void main(String[] args) {
//original array
String[] langArray = {"Python", "Java", "JavaScript", "C++" };
System.out.println("Original Array: " + Arrays.toString(langArray));
//length of original array
int initialLength = langArray.length;
// Adding a new entry to the string array
String newLang= "Go";
// create a new array with a length that is greater than the previous array
String[] newArray = new String[ initialLength + 1 ];
// all the elements of the original array should be copied to the new array
for (int i=0; i <langArray .length; i++)
{
newArray[i] = langArray [i];
}
// near the end of the new array, add a new element
newArray[newArray.length- 1] = newLang;
// create a new Array that is identical to the original array and print it
langArray = newArray;
System.out.println(" Displaying array items after adding a new item: " + Arrays.toString(langArray));
}
} Étant donné que le logiciel doit gérer deux baies, cette technique entraîne une surcharge de mémoire et de performances.
ArrayList comme type de collection
ArrayList en tant que structure de données intermédiaire peut également être utilisée pour ajouter un élément à un tableau String. Voici un exemple.
import java.io.*;
import java.lang.*;
import java.util.*;
class Codeunderscored {
public static void main(String[] args)
{
// initial array definition
String langArray[]
= { "Java", "Python", "C++", "C#", "JavaScript", "Go" };
// printing of the original array
System.out.println("Initial Array:\n"
+ Arrays.toString(langArray));
// new element to be added
String newLang = "Ruby";
// convert the array to arrayList
List<String>langList
= new ArrayList<String>(
Arrays.asList(langArray));
// Add the new element to the arrayList
langList.add(newLang);
// Convert the Arraylist back to array
langArray = langList.toArray(numArray);
// showing the array that has been the changed
System.out.println("\nArray with value " + newLang
+ " added:\n"
+ Arrays.toString(langArray));
}
} Le tableau de chaînes est d'abord transformé en ArrayList à l'aide de la méthode asList, comme indiqué dans l'application ci-dessus. La méthode add est ensuite utilisée pour ajouter le nouvel élément à la ArrayList. Le ArrayList est retransformé en un tableau lorsque l'élément est inséré. Par rapport aux approches précédentes, celle-ci est plus efficace.
Ce que contient un tableau de chaînes
La méthode 'contains' peut déterminer si une chaîne donnée est présente ou non dans le tableau de chaînes. Étant donné que cette méthode appartient à ArrayList, vous devez d'abord convertir le tableau de chaînes en ArrayList. La technique "contient" est illustrée dans l'exemple suivant.
import java.io.*;
import java.lang.*;
import java.util.*;
class Codeunderscored {
public static void main(String[] args)
{
String[] programmingLanguages = new String[]{"C++", "Java", "Go", "C", "Python"};
// Convert String Array to List
List<String>languagesList = Arrays.asList(programmingLanguages);
String languageToCheck = "Java";
if(languagesList .contains(languageToCheck)){
System.out.println("The Langugae " + languageToCheck + " is present in the string array");
}
else
System.out.println("The Language " + languageToCheck + " is not present in string array" );
}
} Nous avons commencé par déterminer si le tableau de chaînes donné contenait la chaîne "Go". Un message pertinent s'affiche puisqu'il est présent. La chaîne à tester est ensuite remplacée par "JavaScript". La méthode "contient" renvoie faux dans ce scénario.
Il convient de noter que la chaîne fournie en tant que paramètre de la fonction contains est toujours sensible à la casse. Si nous passons 'go' comme paramètre à la méthode contains dans l'implémentation ci-dessus, elle renverra false.
Comment trier un tableau de chaînes
Le « tri dans les tableaux » a déjà été traité en profondeur. Les méthodes de tri d'un tableau de chaînes sont similaires à celles utilisées pour trier d'autres tableaux. La méthode ‘sort’ de la classe ‘Arrays’ est implémentée ci-dessous, triant les chaînes du tableau par ordre alphabétique.
import java.util.*;
class Codeunderscored {
public static void main(String[] args)
{
String[] programmingLanguages = {"Python","C++","C#","Python","JavaScript"};
System.out.println("The initial array: "+Arrays.toString(programmingLanguages));
Arrays.sort(programmingLanguages);
System.out.println("Sorted array: "+Arrays.toString(programmingLanguages));
}
} La sortie du logiciel précédent comprend à la fois le tableau d'entrée d'origine et un tableau de sortie trié par ordre alphabétique.
Recherche d'une chaîne dans le tableau de chaînes
Vous pouvez également rechercher une chaîne particulière dans un String Array en parcourant chaque élément du String Array, en plus de la technique "contient" que nous venons de mentionner. Chaque élément du String Array sera comparé à la String à rechercher.
Lorsque la première occurrence de la chaîne est localisée, la recherche est terminée. Ensuite, l'index approprié de la chaîne dans le tableau est renvoyé. Un message pertinent est présenté si la chaîne n'est pas trouvée jusqu'à la fin du tableau de chaînes. Le programme Java suivant illustre cette implémentation.
import java.util.*;
class Codeunderscored {
public static void main(String[] args)
{
String[] compCompanies = { "Google", "DELL", "HP", "IBM", "Air BnB" };
boolean found = false;
int index = 0;
String searchStr = "DELL";
for (int i = 0; i <compCompanies .length; i++) {
if(searchStr.equals(compCompanies[i])) {
index = i; found = true;
break;
}
}
if(found)
System.out.println( searchStr +" is available at the index "+index);
else
System.out.println( searchStr +" is not present in the array");
}
} Lorsque la chaîne 'DELL' est trouvée dans un tableau de chaînes donné, le programme ci-dessus renvoie l'index qui lui correspond.
Conversion de tableau de chaînes en chaînes
Voyons comment créer une chaîne à partir d'un tableau de chaînes. Nous allons passer en revue trois façons alternatives de l'implémenter, chacune avec un exemple.
La méthode toString en action
La première méthode utilise la fonction toString de la classe ‘Arrays’. Il accepte un tableau de chaînes en tant que paramètre et renvoie la représentation sous forme de chaîne du tableau. La méthode toString est illustrée dans l'application Java ci-dessous.
import java.util.*;
public class Codeunderscored {
public static void main(String args[])
{
// string declaration
String[] strArray = {"Coding","is","my","favorite","hobby"};
System.out.println("The String array converted to string:" + Arrays.toString(strArray));
}
} La méthode 'toString' est utilisée dans le logiciel ci-dessus pour afficher la représentation sous forme de chaîne du tableau de chaînes spécifié.
La méthode StringBuilder.Append()
La classe 'StringBuilder' est la prochaine option pour transformer un tableau de chaînes en chaîne. Créez un objet StringBuilder et utilisez la fonction "Append" de StringBuilder pour ajouter les membres du tableau de chaînes à l'objet StringBuilder. Après avoir ajouté tous les membres du tableau à l'objet StringBuilder, vous pouvez utiliser la méthode "toString" pour acquérir la représentation sous forme de chaîne.
import java.util.*;
public class Codeunderscored {
public static void main(String args[])
{
//string array
String[] strArray = {"Coding","is","my","favorite","hobby"};
System.out.print("The initial string array is:");
//print string array
for(String val:strArray)
System.out.print(val + " ");
System.out.println("\n");
//using a string array to create a stringbuilder object
StringBuilder stringBuilder = new StringBuilder();
int i;
for (i= 0; i <strArray.length; i++) {
stringBuilder.append(strArray[i]+ " ");
}
//print the String
System.out.println("obtaining the string from string array:" + stringBuilder.toString());
}
} Le logiciel précédent utilise la classe StringBuilder pour convertir un tableau de chaînes en chaîne.
Employer l'opération de jointure
Vous pouvez également utiliser la fonction "join" de la classe String pour convertir un tableau de chaînes en une représentation sous forme de chaîne. L'action "join" nécessite deux arguments :le premier est le séparateur ou le délimiteur de la chaîne, et le second est le tableau de chaînes. De plus, la chaîne est ensuite séparée par le séparateur fourni par la procédure de jointure (premier argument).
Le programme ci-dessous montre comment utiliser l'opération de jointure pour obtenir une chaîne à partir d'un tableau de chaînes.
import java.util.*;
public class Codeunderscored {
public static void main(String args[])
{
//string array
String[] strArray = {"Coding","is","my","favorite","hobby"};
System.out.println("The initial string array is:");
// string array printing
for(String val:strArray)
System.out.print(val + " ");
System.out.println("\n");
//form a string from string array using join operation
String combinedString = String.join(" ", strArray);
//print the string
System.out.println(" The String that is obtained from string array:" + combinedString);
}
} Conversion d'une chaîne en un tableau équivalent de chaînes
Regardons la conversion d'une chaîne en un tableau de chaînes à l'envers. Cette conversion peut être effectuée de deux manières.
Utilisation de l'opération de fractionnement
L'opération de division de la classe String est la méthode initiale de transformation d'une chaîne en un tableau de chaînes. Un délimiteur (virgule, espace, etc.) peut être utilisé pour séparer une chaîne et renvoyer le tableau de chaînes fraîchement créé. L'opération de fractionnement est illustrée dans l'exemple suivant.
public class Codeunderscored {
public static void main(String args[])
{
//declare a string
String strVar = "This is unit code test prerequisites";
// To split a string into a string array, use the split function.
String[] strArray = strVar.split(" ", 6);
System.out.println("The resultant String Array after splitting the string is \"" + strVar + "\":");
//showing the string array
int i;
for (i=0;i<strArray.length;i++)
System.out.println("strArray[" + i+ "]=" + strArray[i]);
}
}
Le programme ci-dessus divise la chaîne en fonction de l'espace et renvoie un tableau de chaînes à 5 éléments à l'aide de la fonction split.
Utiliser un modèle d'expression régulière
Les expressions régulières sont une approche pour convertir une chaîne en un tableau de chaînes. Vous pouvez définir un modèle, puis la chaîne donnée sera divisée en fonction du modèle. Vous pouvez utiliser la classe Regex Pattern du package Java.util. Un exemple d'application de modèles pour convertir une chaîne en un tableau de chaînes est présenté ci-dessous.
import java.util.Arrays;
import java.util.regex.Pattern;
public class Codeunderscored {
public static void main(String args[])
{
// string declaration
String strVar = "This is unit code test prerequisites";
System.out.println("The initial string is:" + strVar + "\n");
String[] strArray = null;
//split string on space(" ")
Pattern pattern = Pattern.compile(" ");
//using the pattern split on string to get string array
strArray = pattern.split( strVar );
//printing the string array
System.out.println("The resultant String Array after splitting the string using regex pattern:");
for (int i=0;i<strArray .length;i++)
System.out.println("strArray[" + i+ "]=" + strArray[i]);
}
} Le motif que nous avons fourni dans le programme ci-dessus est un caractère espace. Par conséquent, la chaîne est divisée en espaces, renvoyant le tableau de chaînes. Comme vous pouvez le constater, les expressions régulières et les modèles constituent une approche de programmation nettement plus efficace.
Convertir un tableau de chaînes en liste
Vous pouvez également créer une liste à partir d'un tableau de chaînes. Il existe plusieurs façons de procéder que nous avons énumérées ci-dessous.
Utilisation du code personnalisé
La première consiste à transformer un tableau de chaînes en une liste à l'aide d'un code sur mesure. Un tableau de chaînes est parcouru dans cette fonction et chaque membre est ajouté à la liste à l'aide de la méthode add de la liste. Il est démontré dans le programme suivant.
import java.util.*;
public class Codeunderscored
{
public static void main( String[] args )
{
//string array declaration
String[] compCompanies = { "Google", "DELL", "HP", "IBM", "Air BnB" };
System.out.println("The original string array:" + Arrays.toString(compCompanies));
//definition of the arraylist with size same as string array
List<String>strArrayList = new ArrayList<String>(numArray.length);
//add string array elements to arraylist
for (String str:compCompanies) {
strArrayList.add(str );
}
System.out.println("\n The Arraylist that is created from string array:");
//print the arraylist
for (String str : strArrayList)
{
System.out.print(str + " " );
}
}
} Une liste est d'abord produite, comme indiqué dans le programme ci-dessus. La boucle for-each est ensuite utilisée pour ajouter chaque entrée du tableau de chaînes à la liste. La liste est alors imprimée.
Utilisation de la méthode collections.addAll()
La deuxième technique pour transformer un tableau de chaînes en liste consiste à utiliser la méthode "addAll" du framework Collections. La méthode addAll() prend une ArrayList et un tableau de chaînes en entrée et transfère le contenu du tableau de chaînes à la ArrayList. La méthode addAll convertit un tableau de chaînes en une liste dans le logiciel suivant.
import java.util.*;
public class Codeunderscored
{
public static void main( String[] args )
{
//a string array
String[] compArray = { "DELL", "IBM", "Chromebook", "Lenovo", "Toshiba" };
System.out.println("The original string array:" + Arrays.toString(vehiclesArray));
//arraylist with size same as string array definition
List<String> strArrayList = new ArrayList<String>(compArray .length);
//add string array items to arraylist using Collections.addAll method
Collections.addAll(strArrayList, compArray );
System.out.println("\nArraylist is created from string array:");
// arraylist printing
for (String str : strArrayList)
{
System.out.print(str + " " );
}
}
} À l'aide de Collections, nous avons transformé un tableau de chaînes fourni en une liste dans le logiciel précédent. addAll est une méthode qui ajoute tout à une liste.
Utiliser la méthode arrays.asList()
Enfin, la classe Array possède une méthode ‘asList()’ qui convertit directement un tableau de chaînes en une liste. Un programme Java qui utilise asList est illustré ci-dessous.
import java.util.*;
public class Codeunderscored
{
public static void main( String[] args )
{
//a string array
String[] compArray = { "DELL", "IBM", "Chromebook", "Lenovo", "Toshiba" };
System.out.println("The string array:" + Arrays.toString(compArray));
//Conversion of Array to list using asList method
List<String> strArrayList = Arrays.asList( compArray );
System.out.println("\nThe Arraylist created from string array:");
// arraylist printing
for (String str : strArrayList)
{
System.out.print(str + " " );
}
}
} La fonction asList de la classe Arrays convertit un tableau en liste et le renvoie, comme vu ci-dessus.
Comment convertir une liste en tableau de chaînes
Nous avons vu quelques méthodes pour convertir un tableau de chaînes en liste dans la section précédente. Examinons les techniques de conversion d'une liste en un tableau de chaînes.
Utilisation de la méthode ArrayList.get()
La première méthode est la méthode ArrayList get, qui renvoie les éléments de la liste. Vous pouvez parcourir ArrayList et utiliser la méthode get pour récupérer un élément, qui peut ensuite être alloué à un emplacement de tableau. Il est démontré dans le programme suivant.
import java.util.*;
public class Codeunderscored
{
public static void main( String[] args )
{
//ArrayList initialization
ArrayList<String> strArrayList= new ArrayList<String>();
//adding new items to the arraylist
strArrayList.add("maize");
strArrayList.add("beans");
strArrayList.add("potatoes");
strArrayList.add("yams");
strArrayList.add("sorghum");
//ArrayList to Array Conversion
String strArrayVar[] = new String[strArrayList .size()];
for(int j =0;j<strArrayList .size();j++){
strArrayVar[j] = strArrayList.get(j);
}
//print array elements
System.out.println("The String array is obtained from string arraylist:");
for(String ary: strArrayVar){
System.out.print(ary + " ");
}
}
} Les éléments sont d'abord ajoutés à ArrayList, puis la liste est transformée en un tableau de chaînes à l'aide de la méthode "toArray".
Tableau de chaînes vers tableau d'entiers
Vous devrez peut-être effectuer des opérations sur des nombres à un moment donné. Dans ce scénario, si votre tableau de chaînes contient des données numériques, il est recommandé de le convertir en tableau int. Pour ce faire, appliquez la fonction 'parseInt' à chaque élément du tableau et extrayez l'entier. Le programme ci-dessous explique comment convertir un tableau de chaînes en un tableau int.
import java.util.*;
public class Codeunderscored
{
public static void main( String[] args )
{
//string arrya declaration
String [] strVar = {"30", "40","50", "60","70"};
//printing of the string array
System.out.println("The Original String Array:");
for(String val:strVar)
System.out.print(val + " ");
System.out.println("\nThe integer array obtained from string array:");
//declare an int array
int [] intArray = new int [strVar .length];
//assigning the string array values to int array
for(int i=0; i<intArray .length; i++) {
int_Array[i] = Integer.parseInt(str_Array[i]);
}
//display the int array
System.out.println(Arrays.toString(int_Array));
}
} Nous avons un tableau de chaînes dans l'application ci-dessus qui inclut les nombres sous forme de chaînes. Chaque élément du tableau de chaînes est analysé à l'aide de la fonction "parseInt" et affecté à un tableau int dans ce programme. Cette conversion ne fonctionnera qu'avec un tableau de chaînes avec des membres numériques. Le compilateur lève une 'java.lang.NumberFormatException' si l'une des entrées du tableau de chaînes n'est pas numérique.
Conclusion
En Java, un tableau est une structure de données fondamentale et largement utilisée. Le tableau est une collection d'éléments de type de données comparables. En fait, c'est l'une des structures de données les plus couramment utilisées par les programmeurs en raison de son efficacité et de sa productivité. Les éléments sont stockés dans une seule région de mémoire.
Un tableau comprenant un nombre fixe de valeurs de chaîne est appelé tableau de chaînes. D'autre part, une succession de caractères est appelée une chaîne. Une chaîne est un objet immuable, ce qui signifie que sa valeur ne peut pas être modifiée. De plus, le String Array fonctionne de la même manière que les autres types de données Array.
