Tableau de chaînes Java - Tutoriel avec des exemples de code

java string array tutorial with code examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Ce didacticiel sur Java String Array explique comment déclarer, initialiser et créer des tableaux de chaînes en Java et des conversions que nous pouvons effectuer sur un tableau de chaînes:

Les tableaux sont une structure de données importante en Java qui sont utilisées pour stocker différents types de données, des primitives aux données définies par l'utilisateur. Nous avons déjà vu les bases des tableaux et les autres opérations majeures qui peuvent être effectuées sur les tableaux.

Dans l'un de nos didacticiels précédents, nous avons discuté des différents types de données qu'un Array peut contenir.

=> Formation A-Z de Java pour les débutants

Tableau de chaînes Java et diverses méthodes

L'un des types de données que les tableaux peuvent contenir est une chaîne. Dans ce cas, le tableau est appelé un tableau String.

Ce que vous apprendrez:

Qu'est-ce qu'un tableau de chaînes en Java?
Conclusion
- lecture recommandée

Qu'est-ce qu'un tableau de chaînes en Java?

Nous pouvons avoir un tableau avec des chaînes comme éléments. Ainsi, nous pouvons définir un tableau de chaînes comme un tableau contenant un nombre fixe de chaînes ou de valeurs de chaîne. Le tableau de chaînes est l'une des structures les plus couramment utilisées en Java. Si vous vous en souvenez, même l’argument de la fonction «main» en Java est un tableau de chaînes.

Le tableau de chaînes est un tableau d'objets. En effet, chaque élément est une chaîne et vous savez qu'en Java, String est un objet. Vous pouvez effectuer toutes les opérations sur le tableau String comme le tri, l'ajout d'un élément, la jointure, le fractionnement, la recherche, etc.

Dans ce didacticiel, nous aborderons en détail le tableau de chaînes en Java ainsi que les différentes opérations et conversions que nous pouvons effectuer sur des tableaux de chaînes.

Déclaration d'un tableau de chaînes

Un tableau de chaînes peut être déclaré de deux manières, c'est-à-dire avec une taille ou sans spécifier la taille.

Vous trouverez ci-dessous les deux façons de déclarer un tableau de chaînes.

String() myarray ; //String array declaration without size String() myarray = new String(5);//String array declaration with size

Dans la première déclaration, un String Array est déclaré comme une variable normale sans aucune taille. Notez qu'avant d'utiliser ce tableau, vous devrez l'instancier avec new.

Dans la deuxième déclaration, un String Array est déclaré et instancié à l'aide de new. Ici, un tableau String 'myarray' avec cinq éléments est déclaré. Si vous imprimez directement les éléments de ce tableau, vous verrez toutes les valeurs nulles car le tableau n'est pas initialisé.

Implémentons un programme qui affiche une déclaration String Array.

 public class Main { public static void main(String() args) { String() myarray; //declaration of string array without size String() strArray = new String(5); //declaration with size //System.out.println(myarray(0)); //variable myarray might not have been initialized //display elements of second array System.out.print(strArray(0) + ' ' +strArray(1)+ ' ' + strArray(2)+ ' ' + strArray(3)+ ' ' +strArray(4)); } }

Production:

Déclaration d

Le programme ci-dessus montre deux façons de déclarer un tableau de chaînes. Comme mentionné précédemment, la première déclaration est sans taille ni instanciation. Par conséquent, avant d'utiliser ce tableau, vous devez l'instancier en utilisant new. Dans le programme ci-dessus, le tableau myarray est utilisé sans instanciation et entraîne donc une erreur du compilateur (instruction commentée).

La deuxième déclaration concerne la taille. Ainsi, lorsque des éléments individuels de ce tableau String sont imprimés, les valeurs de tous les éléments sont nulles car le tableau n'a pas été initialisé.

Initialisation d'un tableau de chaînes

Une fois que le tableau de chaînes est déclaré, vous devez l'initialiser avec certaines valeurs. Sinon, les valeurs par défaut affectées aux éléments String sont nulles. Ainsi, après la déclaration, nous procédons à l'initialisation du tableau.

Un tableau String peut être initialisé en ligne avec la déclaration ou il peut être initialisé après l'avoir déclaré.

Voyons d'abord comment un tableau String peut être initialisé en ligne.

 String() numarray = {“one”, “two”, “three”}; String() strArray = new String() {“one”, “two”, “three”, “four”};

Dans le tableau de chaînes ci-dessus, les initialisations sont des initialisations en ligne. Le String Array est initialisé en même temps qu'il est déclaré.

Vous pouvez également initialiser le tableau de chaînes comme suit:

String() strArray = new String(3); strArray(0) = “one”; strArray(1) = “two”; strArray(2) = “three”;

Ici, le String Array est déclaré en premier. Ensuite, dans la ligne suivante, les éléments individuels reçoivent des valeurs. Une fois que le String Array est initialisé, vous pouvez l'utiliser normalement dans votre programme.

Longueur / taille d'un tableau de chaînes

Vous savez que pour obtenir la taille du tableau, les tableaux ont une propriété nommée «longueur». Cela est également vrai pour les tableaux de chaînes.

La taille ou la longueur du tableau (tout tableau) donne le nombre d'éléments présents dans le tableau. Ainsi, afin d'obtenir la longueur du tableau nommé myarray, vous pouvez donner l'expression suivante.

int len = myarray.length;

Implémentons un programme qui affichera la longueur d'un tableau de chaînes.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; int len = numArray.length; //get the length of array //display the length System.out.println('Length of numArray{'one','two', 'three', 'four', 'five'}:' + len); } }

Production:

Taille d

La propriété length est utile lorsque vous devez parcourir un tableau de chaînes pour le traiter ou simplement l'imprimer.

Itération et impression d'un tableau de chaînes

Jusqu'à présent, nous avons discuté de la déclaration, de l'initialisation et de la propriété length d'un String Array, et il est maintenant temps pour nous de parcourir chaque élément du tableau et également d'imprimer les éléments String Array.

Comme avec tous les tableaux, vous pouvez parcourir un tableau de chaînes en utilisant la boucle for et la boucle for améliorée.

Ci-dessous est un Implémentation Java qui illustre l'utilisation d'une boucle for améliorée pour parcourir / itérer le tableau et imprimer ses éléments.

 public class Main { public static void main(String() args) { //declare and initialize a string array String() numArray = {'one','two', 'three', 'four', 'five'}; System.out.println('String Array elements displayed using for loop:'); // for loop to iterate over the string array for(int i=0; i Production: 
  
 Dans le programme ci-dessus, la boucle for et la boucle for améliorée sont utilisées pour parcourir le tableau de chaînes. Notez que dans le cas d'une boucle for améliorée, il n'est pas nécessaire de spécifier la condition de limite ou de fin. Dans le cas de la boucle «for», vous devez spécifier la condition de début et de fin.
 Ajouter au tableau de chaînes
 Tout comme les autres types de données, vous pouvez également ajouter des éléments pour les tableaux de chaînes. Dans cette section, voyons les différentes méthodes pour ajouter un élément au tableau de chaînes.
 Utilisation de la pré-allocation
 Dans cette méthode, vous créez un tableau de plus grande taille. Par exemple, si vous devez stocker 5 éléments dans le tableau, vous allez créer un tableau de taille 10. De cette façon, vous pouvez facilement ajouter de nouveaux éléments à la fin du tableau.
  Un exemple qui implémente l'ajout d'un élément au tableau pré-alloué est illustré ci-dessous. 
 import java.util.*; public class Main { public static void main(String() args) { String() colorsArray = new String(5); // initial array values colorsArray(0) = 'Red'; colorsArray(1) = 'Green'; colorsArray(2) = 'Blue'; System.out.println('Original Array:' + Arrays.toString(colorsArray)); intnumberOfItems = 3; // try to add new value at the end of the array String newItem = 'Yellow'; colorsArray(numberOfItems++) = newItem; System.out.println('Array after adding one element:' + Arrays.toString(colorsArray)); } }  Production: 
  
 Notez que l'espace inoccupé dans le tableau est défini sur Null. L'inconvénient de cette méthode est qu'il y a un gaspillage d'espace car vous pourriez créer un grand tableau qui peut rester inoccupé.
 Utilisation d'une nouvelle matrice
 Dans cette méthode, vous créez un nouveau tableau dont la taille est supérieure à celle du tableau d'origine afin de pouvoir accueillir le nouvel élément. Après avoir créé le nouveau tableau, tous les éléments du tableau d'origine sont copiés dans ce tableau, puis le nouvel élément est ajouté à la fin du tableau.
  Un exemple de programme pour ajouter un élément à l'aide du nouveau tableau est illustré ci-dessous. 
les périphériques de modèle osi utilisent chaque couche
 importjava.util.*; public class Main { public static void main(String() args) { //original array String() colorsArray = {'Red', 'Green', 'Blue' }; System.out.println('Original Array: ' + Arrays.toString(colorsArray)); //length of original array int orig_length = colorsArray.length; //new element to be added to string array String newElement = 'Orange'; //define new array with length more than the original array String() newArray = new String( orig_length + 1 ); //add all elements of original array to new array for (int i=0; i  Production: 
  
 Cette approche entraîne clairement une surcharge de mémoire et de performances car vous devez maintenir deux tableaux dans le programme.
 Utilisation de ArrayList
 Vous pouvez également ajouter un élément au tableau String en utilisant ArrayList comme structure de données intermédiaire.
Questions et réponses d'entretien de loadrunner pour les expérimentés
  Un exemple est présenté ci-dessous. 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { // define initial array String numArray() = { 'one', 'two', 'three', 'four', 'five', 'six' }; // print the original array System.out.println('Initial Array:
' + Arrays.toString(numArray)); // new element to be added String newElement = 'seven'; // convert the array to arrayList ListnumList = new ArrayList( Arrays.asList(numArray)); // Add the new element to the arrayList numList.add(newElement); // Convert the Arraylist back to array numArray = numList.toArray(numArray); // print the changed array System.out.println('
Array with value ' + newElement + ' added:
' + Arrays.toString(numArray)); } }  Production: 
  
 Comme indiqué dans le programme ci-dessus, le tableau de chaînes est d'abord converti en ArrayList à l'aide de la méthode asList. Ensuite, le nouvel élément est ajouté à ArrayList à l'aide de la méthode add. Une fois l'élément ajouté, le ArrayList est reconverti en tableau.
 Il s'agit d'une approche plus efficace par rapport à celles évoquées précédemment.
 Le tableau de chaînes contient
 Si vous souhaitez savoir si une certaine chaîne est présente ou non dans le tableau de chaînes, vous pouvez utiliser la méthode ‘contains’. Pour cela, vous devez d'abord convertir le tableau de chaînes en ArrayList car cette méthode appartient à ArrayList.
  L’implémentation suivante montre l’utilisation de la méthode «contient». 
 import java.io.*; import java.lang.*; import java.util.*; class Main { public static void main(String() args) { String() words = new String(){'C++', 'Java', 'C', 'Python'}; // Convert String Array to List Listwordslist = Arrays.asList(words); String tochk = 'Java'; if(wordslist.contains(tochk)){ System.out.println('The word ' + tochk + ' present in string array'); } else System.out.println('The word ' + tochk + ' not present in string array' ); } }  Production: 
  
 Tout d'abord, nous avons vérifié si le tableau de chaînes donné contient la chaîne «Java». Comme il est présent, un message approprié s'affiche. Ensuite, nous changeons la chaîne à vérifier en «C #». Dans ce cas, la méthode «contient» renvoie false.
  
 Notez que, pour la méthode contains, la chaîne passée en argument est toujours sensible à la casse. Ainsi, dans l'implémentation ci-dessus, si nous fournissons «java» comme argument à la méthode contains, alors il retournera false.
 Trier un tableau de chaînes
 Nous avons déjà vu un sujet détaillé sur «Trier dans les tableaux». Les méthodes pour trier un tableau de chaînes sont les mêmes que les autres tableaux.
  Ci-dessous se trouve une implémentation de la méthode «sort» de la classe «Arrays» qui trie les chaînes du tableau par ordre alphabétique. 
 import java.util.*; class Main { public static void main(String() args) { String() colors = {'red','green','blue','white','orange'}; System.out.println('Original array: '+Arrays.toString(colors)); Arrays.sort(colors); System.out.println('Sorted array: '+Arrays.toString(colors)); } } Production: 
  
 La sortie du programme ci-dessus montre le tableau d'entrée d'origine ainsi que le tableau de sortie qui est trié par ordre alphabétique.
 Rechercher une chaîne dans le tableau de chaînes
 Outre la méthode «contient» dont nous venons de parler, vous pouvez également rechercher une chaîne particulière dans un tableau de chaînes en parcourant chaque élément du tableau de chaînes. Ici, vous comparerez chaque élément du tableau de chaînes avec la chaîne à rechercher.
 La recherche est terminée lorsque la première occurrence de la chaîne est trouvée et que l'index correspondant de la chaîne dans le tableau est renvoyé. Si la chaîne n'est pas trouvée jusqu'à la fin du tableau de chaînes, un message approprié s'affiche.
  Cette implémentation est illustrée dans le programme Java suivant. 
 import java.util.*; class Main { public static void main(String() args) { String() strArray = { 'Book', 'Pencil', 'Eraser', 'Color', 'Pen' }; boolean found = false; int index = 0; String searchStr = 'Pen'; for (int i = 0; i  Production: 
  
 Le programme ci-dessus recherche la chaîne «Pen» dans un tableau de chaînes donné et renvoie son index correspondant lorsqu'il est trouvé.
 Convertir un tableau de chaînes en chaîne
 Voyons comment convertir un tableau de chaînes en chaîne. Nous allons discuter de trois méthodes différentes pour ce faire avec un exemple de chacune.
 Utilisation de la méthode toString
 La première méthode utilise la méthode «toString» de la classe «Arrays». Il prend le tableau de chaînes comme argument et renvoie la représentation sous forme de chaîne du tableau.
  Le programme Java suivant montre l'utilisation de la méthode toString. 
 import java.util.*; public class Main { public static void main(String args()) { //declare a string String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('String array converted to string:' + Arrays.toString(str_Array)); } }  Production: 
  
 Le programme ci-dessus utilise la méthode «toString» pour afficher la représentation sous forme de chaîne du tableau de chaînes donné.
 Utilisation de la méthode StringBuilder.Append ()
 La prochaine approche de conversion d'un tableau de chaînes en chaîne consiste à utiliser la classe «StringBuilder». Vous devez créer un objet de type StringBuilder et utiliser la méthode ‘Append’ de StringBuilder pour ajouter les éléments du tableau de chaînes à l’objet StringBuilder un par un.
 Une fois que tous les éléments du tableau sont ajoutés à l’objet StringBuilder, vous pouvez utiliser la méthode «toString» sur cet objet pour enfin obtenir la représentation sous forme de chaîne.
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.print('Original string array:'); //print string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //construct a stringbuilder object from given string array StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i  Production: 
  
 Le programme ci-dessus montre la conversion d'un tableau de chaînes en chaîne à l'aide de la classe StringBuilder.
 Utilisation de l'opération de jointure
 Vous pouvez également utiliser l’opération ‘join’ de la classe String pour transformer le tableau de chaînes en une représentation sous forme de chaîne.
 L’opération de «jointure» prend deux arguments, le premier est le séparateur ou le délimiteur de la chaîne et le second argument est le tableau de chaînes. L'opération de jointure renvoie ensuite la chaîne séparée par un séparateur spécifié (premier argument).
  Vérifiez le programme suivant qui illustre l'utilisation de l'opération de jointure pour obtenir une chaîne à partir d'un tableau de chaînes. 
 import java.util.*; public class Main { public static void main(String args()) { //string array String() str_Array = {'This','is','Software','Testing','Help'}; System.out.println('Original string array:'); //print the string array for(String val:str_Array) System.out.print(val + ' '); System.out.println('
'); //form a string from string array using join operation String joinedString = String.join(' ', str_Array); //print the string System.out.println('String obtained from string array:' + joinedString); } }  Production: 
  
 Convertir une chaîne en tableau de chaînes
 Voyons l’opération inverse de conversion d’une chaîne en tableau de chaînes. Il existe deux méthodes pour effectuer cette conversion.
 Utilisation de l'opération fractionnée
 La première méthode de conversion d'une chaîne en tableau de chaînes consiste à utiliser l'opération de fractionnement de la classe String. Vous pouvez diviser la chaîne sur un délimiteur spécifié (virgule, espace, etc.) et renvoyer le tableau de chaînes nouvellement généré.
  L'implémentation suivante illustre l'utilisation de l'opération de fractionnement. 
 public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Software Testing Help'; //use split function to split the string into a string array String() str_Array = myStr.split(' ', 5); System.out.println('String Array after splitting the string '' + myStr + '':'); //display the string array for (int i=0;i
 Le programme ci-dessus utilise la fonction de fractionnement pour fractionner la chaîne en fonction de l'espace et renvoie un tableau de chaînes à 5 éléments.
 Utilisation du modèle Regex
 La méthode suivante pour convertir la chaîne en un tableau de chaînes consiste à utiliser des expressions régulières. Vous pouvez spécifier un modèle, puis diviser la chaîne donnée selon le modèle spécifié.
 Vous pouvez utiliser Classe de modèle d'expression régulière appartenant au package java.util.
  Vous trouverez ci-dessous un exemple d'utilisation de modèles pour convertir une chaîne en String Array. 
 import java.util.Arrays; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //declare a string String myStr = 'This is Java series tutorial'; System.out.println('The original string:' + myStr + '
'); String() str_Array = null; //split string on space(' ') Pattern pattern = Pattern.compile(' '); //use pattern split on string to get string array str_Array = pattern.split(myStr ); //print the string array System.out.println('String Array after splitting the string using regex pattern:'); for (int i=0;i
 Dans le programme ci-dessus, le modèle que nous avons spécifié est un caractère d'espace. Ainsi, la chaîne est divisée en espaces et renvoie le tableau de chaînes. Comme vous pouvez déjà le déduire, l'utilisation d'expressions régulières et de modèles est un moyen de programmation beaucoup plus efficace.
 Convertir un tableau de chaînes en liste
 Vous pouvez également convertir un tableau de chaînes en liste. Nous avons répertorié quelques méthodes pour ce faire
 Utilisation du code personnalisé
 La première méthode consiste à utiliser un code personnalisé pour convertir un tableau de chaînes en liste. Dans cette méthode, un tableau de chaînes est parcouru et chaque élément est ajouté à la liste à l'aide de la méthode add de la liste.
  Le programme suivant montre cette implémentation. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() numArray = { 'One', 'Two', 'Three', 'Four', 'Five' }; System.out.println('The string array:' + Arrays.toString(numArray)); //define arraylist with size same as string array Liststr_ArrayList = new ArrayList(numArray.length); //add string array elements to arraylist for (String str:numArray) { str_ArrayList.add(str ); } System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Production: 
  
 Comme indiqué dans le programme ci-dessus, une liste est créée en premier. Ensuite, en utilisant la boucle for-each, chaque élément du tableau de chaînes est ajouté à la liste. Enfin, la liste est imprimée.
 Utilisation de la méthode Collections.addAll ()
 La deuxième méthode de conversion d'un tableau de chaînes en liste consiste à utiliser la méthode «addAll» du framework Collections. La méthode addAll () prend ArrayList et le tableau de chaînes en entrée et copie le contenu du tableau de chaînes dans ArrayList.
  Le programme suivant montre l'utilisation de la méthode addAll pour convertir un tableau de chaînes en liste. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //define arraylist with size same as string array List str_ArrayList = new ArrayList(vehiclesArray.length); //add string array elements to arraylist using Collections.addAll method Collections.addAll(str_ArrayList, vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Production: 
  
 Dans le programme ci-dessus, nous avons converti un tableau de chaînes donné en une liste à l'aide de la méthode Collections.addAll.
 Utilisation de Arrays.asList ()
 Enfin, la classe Array fournit la méthode «asList ()» qui convertit directement le tableau de chaînes donné dans la liste.
etl testing questions et réponses d'entrevue
  Ci-dessous est un programme Java qui utilise asList. 
 import java.util.*; public class Main { public static void main( String() args ) { //a string array String() vehiclesArray = { 'moped', 'car', 'SUV', 'bicycle', 'bus' }; System.out.println('The string array:' + Arrays.toString(vehiclesArray)); //Convert array to list using asList method List str_ArrayList = Arrays.asList(vehiclesArray ); System.out.println('
Arraylist created from string array:'); //print the arraylist for (String str : str_ArrayList) { System.out.print(str + ' ' ); } } }  Production: 
  
 Comme indiqué ci-dessus, la méthode asList de la classe Arrays convertit le tableau en liste et renvoie cette liste.
 Convertir la liste en tableau de chaînes
 Dans la section précédente, nous avons vu quelques méthodes pour convertir un tableau de chaînes en liste. Voyons maintenant les méthodes pour convertir la liste en un tableau de chaînes.
 Utiliser ArraList.get ()
 La première méthode est la méthode get a de ArrayList qui renvoie les éléments individuels de la liste. Vous pouvez parcourir ArrayList et appeler la méthode get qui renverra un élément qui peut ensuite être affecté à l'emplacement du tableau.
  Le programme suivant montre cette implémentation. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('str1'); str_ArrayList.add('str2'); str_ArrayList.add('str3'); str_ArrayList.add('str4'); str_ArrayList.add('str5'); //ArrayList to Array Conversion String str_Array() = new String(str_ArrayList.size()); for(int j =0;j Production: 
  
 Le programme ci-dessus montre la conversion de ArrayList en tableau de chaînes à l'aide de la méthode get.
 Utilisation de la méthode ArrayList.toArray ()
 ArrayList fournit une méthode «toArray ()» qui renvoie une représentation sous forme de tableau de ArrayList. Ainsi, vous pouvez obtenir un tableau de chaînes à partir d'une chaîne ArrayList à l'aide de cette méthode.
  Vérifiez le programme suivant qui utilise la méthode toArray. 
 import java.util.*; public class Main { public static void main( String() args ) { //ArrayList initialization ArrayList str_ArrayList= new ArrayList(); //add items to the arraylist str_ArrayList.add('Mumbai'); str_ArrayList.add('Delhi'); str_ArrayList.add('Pune'); str_ArrayList.add('Chennai'); str_ArrayList.add('Kolkata'); //ArrayList to Array Conversion using toArray method String str_Array()=str_ArrayList.toArray(new String(str_ArrayList.size())); //print array elements System.out.println('String array obtained from string arraylist:'); for(String ary: str_Array){ System.out.print(ary + ' '); } } }  Production: 
  
 Tout d’abord, les éléments sont ajoutés à ArrayList, puis en utilisant la méthode ‘toArray’, la liste est convertie en un tableau de chaînes.
 Convertir un tableau de chaînes en tableau int
 Parfois, vous devrez peut-être effectuer des opérations sur les nombres. Dans ce cas, si votre tableau de chaînes a un contenu numérique, il est conseillé de convertir ce tableau de chaînes en tableau int. Pour cela, vous devez utiliser la fonction «parseInt» sur chaque élément du tableau et extraire l’entier.
  Le programme suivant montre la conversion d'un tableau de chaînes en un tableau int. 
 import java.util.*; public class Main { public static void main( String() args ) { //string arrya declaration String () str_Array = {'10', '20','30', '40','50'}; //print the string array System.out.println('Original String Array:'); for(String val:str_Array) System.out.print(val + ' '); System.out.println('
The integer array obtained from string array:'); //declare an int array int () int_Array = new int (str_Array.length); //assign string array values to int array for(int i=0; i Production: 
  
 Dans le programme ci-dessus, nous avons un tableau de chaînes qui contient les nombres sous forme de chaînes. Dans ce programme, chacun des éléments du tableau de chaînes est analysé à l’aide de la fonction ‘parseInt’ et affecté à un tableau de type int.
 Notez que cette conversion ne fonctionnera que sur un tableau de chaînes contenant des éléments numériques. Si l’un des éléments du tableau de chaînes n’est pas numérique, le compilateur lance ‘java.lang.NumberFormatException’.
 Questions fréquemment posées
  Q # 1) Quelle est la différence entre un tableau et une chaîne en Java? 
  Répondre:  Le tableau est une séquence contiguë d'éléments. La chaîne est une séquence de caractères terminée par un caractère nul. Les chaînes sont immuables, c'est-à-dire qu'une fois définies, elles ne peuvent pas être modifiées. Toutes les modifications apportées à la chaîne entraînent une nouvelle chaîne.
 Les tableaux sont mutables. Les tableaux peuvent contenir des éléments de divers types de données, y compris des chaînes.
  Q # 2) Comment déclarez-vous un tableau en Java? 
  Répondre: La manière générale de déclarer un tableau en java est:
  type nom_tableau ();  
Ou 
  type () nom_tableau; 
 Par conséquent, si myarray est une variable de tableau avec des éléments de type int, ce tableau peut être déclaré comme:
  int myarray ();  
Ou 
  int () myarray; 
  Q # 3) Comment créer un tableau de chaînes? 
  Répondre: Si strArray est un tableau de chaînes, sa déclaration peut être:
  String () strArray;  
Ou 
  String strArray (); 
  Q # 4) Qu'est-ce que String () args? 
  Répondre: String () args en Java est un tableau de chaînes contenant des arguments de ligne de commande pouvant être passés à un programme Java.
  Q # 5) Les tableaux peuvent-ils contenir des chaînes? 
  Répondre:  Oui. Tout comme les tableaux peuvent contenir d'autres types de données comme char, int, float, les tableaux peuvent également contenir des chaînes. Dans ce cas, le tableau devient un tableau de «tableau de caractères» car la chaîne peut être considérée comme une séquence ou un tableau de caractères.
 Conclusion
 Dans ce tutoriel, nous avons vu les détails du String Array en Java. Nous avons passé en revue tous les principaux concepts liés à String Array, y compris la déclaration, la définition et l'initialisation du tableau de chaînes en Java.
 Nous avons également discuté de plusieurs opérations comme la recherche, le tri, la jointure, etc. et la conversion d'un tableau de chaînes en liste, chaîne, tableau int, etc. Avec cela, nous complétons notre discussion sur les tableaux de chaînes.
   Dans nos tutoriels suivants, nous aborderons les tableaux multidimensionnels en Java.  
  => Apprenez Java à partir de zéro ici  
  lecture recommandée
    Tutoriel Java Array Length avec des exemples de code  
  Tutoriel Java String with String Buffer et String Builder  
  Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques  
  Comment trier un tableau en Java - Tutoriel avec des exemples  
  Inverser un tableau en Java - 3 méthodes avec des exemples  
  Tutoriel C # String - Méthodes de chaîne avec des exemples de code  
  String Array C ++: implémentation et représentation avec des exemples  
  Mot-clé Java 'this': Tutoriel avec des exemples de code