Top 50 des questions et réponses d'entretien avec Array (2024)

Voici les questions et réponses d'entretien avec Array pour les candidats débutants et expérimentés pour obtenir l'emploi de leurs rêves. Les tableaux font partie intégrante de la programmation et divers langages de codage comme C, C++, Python, Java et Perl utilisent des tableaux.

1) Qu'entendez-vous par un tableau ?

  • Un tableau est un ensemble de types de données similaires.
  • Les objets tableaux stockent plusieurs variables du même type.
  • Il peut contenir des types primitifs et des références d’objets.
  • Les tableaux sont toujours fixes

Téléchargement gratuit du PDF : Questions et réponses pour l'entretien avec Array


2) Comment créer un tableau ?

Un tableau est déclaré de la même manière qu'une variable est déclarée, mais vous devez ajouter [] après le type. Mise en situation : int [] intArray; Nous pouvons déclarer un tableau Java comme un champ, un champ statique, une variable locale ou un paramètre, comme toute autre variable. Un tableau est une collection de variables de ce type. Voici quelques exemples supplémentaires de déclaration de tableau Java :
String [] stringArray;
MyClass [] myClassArray;
Il en va de même pour les autres langages de programmation.

3) Avantages et inconvénients d’Array ?

Avantages:
  • Nous pouvons mettre en place d'autres structures de données comme des piles, des files d'attente, des listes chaînées, des arbres, des graphiques, etc. dans Array.
  • Les tableaux peuvent trier plusieurs éléments à la fois.
  • Nous pouvons accéder à un élément de Array en utilisant un index.
Désavantages:
  • Nous devons déclarer la taille d'un tableau à l'avance. Cependant, nous ne savons peut-être pas de quelle taille nous avons besoin au moment de la déclaration du tableau.
  • Le tableau est une structure statique. Cela signifie que la taille du tableau est toujours fixe, nous ne pouvons donc pas augmenter ou diminuer l'allocation de mémoire.

4) Pouvons-nous modifier la taille d’un tableau au moment de l’exécution ?

Non, nous ne pouvons pas modifier la taille du tableau. Bien qu'il existe des types de données similaires disponibles qui permettent un changement de taille.
Questions d'entretiens chez Array

5) Pouvez-vous déclarer un tableau sans affecter la taille d'un tableau ?

Non, nous ne pouvons pas déclarer un tableau sans attribuer de taille. Si nous déclarons un tableau sans taille, cela générera une erreur de compilation Mise en situation : marques = new int []; // ERREUR DU COMPILATEUR

6) Quelle est la valeur par défaut de Array ?

Tout nouveau tableau est toujours initialisé avec une valeur par défaut comme suit
  • Pour byte, short, int, long – la valeur par défaut est zéro (0).
  • Pour float, double – la valeur par défaut est 0.0.
  • Pour Boolean – la valeur par défaut est false.
  • Pour l'objet – la valeur par défaut est nulle.

7) Comment imprimer un élément du tableau ?

Voici le code pour imprimer l'élément du tableau.
int schoolmarks [] = {25, 30, 50, 10, 5 };

System.out.println (Arrays.toString (schoolmarks));
La sortie est: [25, 30, 50, 10, 5]

8) Comment comparer deux tableaux ?

Si 2 tableaux ont la même taille et le même type de données, la comparaison peut être effectuée en utilisant « Arrays.equal () »
int [] num1 = { 1, 2, 3 };

int[] num2 = { 4, 5, 6 };

System.out.println (Arrays. Equals (num1, num2)); //false

Int [] num3 = {1, 2, 3};

System.out.println (Arrays.equals (num1, num3)); //true

9) Comment trier un tableau ?

C'est possible en utilisant la méthode statique construite qu'est Arrays. trier ().
Int Marks [] = {12, 5, 7, 9};

Arrays.sort(Marks);

System.out.println(Arrays.toString(Marks));//[5, 7, 9, 12]

10) Pouvons-nous déclarer la taille du tableau comme un nombre négatif ?

Non, nous ne pouvons pas déclarer l’entier négatif comme taille de tableau. Si nous déclarons, il n’y aura pas d’erreur de compilation. Cependant, nous obtiendrons NegativeArraySizeException au moment de l'exécution.

11) Quand aurons-nous ArrayStoreException ?

Il s'agit d'une exception d'exécution. Par exemple, nous pouvons stocker uniquement des éléments de chaîne dans un tableau de chaînes. Si quelqu'un essaie d'insérer un élément entier dans ce tableau de chaînes, nous obtiendrons ArrayStoreException au moment de l'exécution.

12) Pouvons-nous ajouter ou supprimer un élément après avoir attribué un tableau ?

Non ce n'est pas possible.

13) Quelle est la signification d’un tableau anonyme ? Expliquez avec un exemple ?

Un tableau anonyme signifie un tableau sans aucune référence. Exemple:-
//Creating anonymous arrays

System.out.println(new int[]{11, 12, 13, 14, 15}.length); //Output : 5

System.out.println(new int[]{31, 94, 75, 64, 41}[1]); //Output : 94 }}

14) Y a-t-il une différence entre int[] a et int a[] ?

Aucune différence, les deux sont les légal déclaration.

15) Il existe 2 types de données de tableau de type int. L'un contient 50 éléments et l'autre contient 30 éléments. Peut-on affecter le tableau de 50 éléments à un tableau de 30 éléments ?

Oui, nous pouvons attribuer à condition qu'ils soient du même type. Le compilateur vérifiera uniquement le type du tableau, pas sa taille.
int[] ab = new int[30];

int[] cd = new int[50];

a = b; //Compiler checks only type, not the size

16) int a[] = new int[3]{1, 2, 3} – est-ce une bonne façon de déclarer des tableaux en Java ?

Non, nous ne devons pas mentionner la taille du tableau lorsque nous fournissons les éléments du tableau.

17) Comment copier un tableau dans un autre tableau ?

Ci-dessous quatre astuces sont disponibles en java pour copier un tableau.
  1. Utilisation de la « boucle For »
  2. Utilisation de la méthode « Arrays.copyOf() »
  3. Utilisation de la méthode « System.arraycopy() »
  4. Utilisation de la méthode « clone() »

18) Que sont les tableaux « irréguliers » en Java ?

Les tableaux irréguliers sont des tableaux contenant des tableaux de longueurs différentes. Les tableaux irréguliers sont également appelés tableaux multidimensionnels.

19) Quand ArrayIndexOutOfBoundsException se produit ?

Il s'agit d'une exception d'exécution. Cela se produira lorsque le programme tentera d’accéder à l’index non valide d’un tableau. Index supérieur à la taille du tableau ou index négatif.

20) Pouvez-vous expliquer les différentes étapes de déclaration de tableaux multidimensionnels en Java ?

//2D Arrays

int[][] twoArray1;

int twoArray2[][];

int[] twoArray3[];

//3D Arrays

int[][][] threeArray1;

int threeArray2[][][];

int[] threeArray3[][];

int[][] threeArray4[];

//4D Arrays

int[][][][] fourArray1;

int fourArray2[][][][];

int[] fourArray3[][][];

int[][] fourArray4[][];

int[][][] fourArray5[];

21) Comment rechercher un élément spécifique dans un tableau ?

Nous pouvons utiliser la méthode Arrays.binarySearch(). Cette méthode utilise un algorithme de recherche binaire.

22) Si vous n’initialisez pas un tableau, que se passera-t-il ?

Le tableau aura une valeur par défaut.

23) Comment trouver les éléments en double dans un tableau ?

Utilisation de la méthode de la force brute : Dans cette méthode, nous comparons chaque élément d’un tableau avec d’autres éléments. Si deux éléments sont égaux ou identiques, nous les déclarons comme doublons. Veuillez trouver ci-dessous le code pour le même
public class DuplicatesInArray {

public static void main(String[] args) {

String[] strArray1 = {"abc1", "def1", "mno1", "xyz1", "pqr1", "xyz1", "def1"};

for (int i = 0; i < strArray1.length-1; i++) {

for (int j = i+1; j < strArray1.length; j++) {

if( (strArray1[i].equals(strArray1[j])) && (i != j) ) {

System.out.println("Duplicates : "+strArray1[j]);

}}}} }
Sortie : L'élément en double est : def1 L'élément en double est : xyz1

24) Pouvons-nous utiliser des génériques avec le tableau ?

Non, nous ne pouvons pas utiliser Generic avec un tableau.

25) Comment parcourir un tableau en Java ?

1) Utilisation de la boucle for normale
public class MainClass1

{

public static void main(String[] args)

{

int[] a1 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using normal for loop

for (int i = 0; i < a1.length; i++)

{

System.out.println(a1[i]);

}}}
2) Utilisation d'une nouvelle boucle for étendue
public class MainClass1

{

public static void main(String[] args)
{
int[] a2 = new int[]{45, 12, 78, 34, 89, 21};

//Iterating over an array using extended for loop

for (int i: a2){

System.out.println(i);

}}}

26) Où est la mémoire allouée aux tableaux en Java ?

En Java, la mémoire des tableaux est toujours allouée sur le tas, car les tableaux en Java sont des objets.

27) Pouvez-vous me dire le nom de classe d’un tableau en Java ?

Le tableau est un objet. Pour récupérer le nom de la classe, nous pouvons utiliser la méthode getClass().getName() sur l'objet.

28) « int a[] = new int[3]{1, 2, 3} » – Est-ce une manière légale de définir les tableaux ?

Non, nous ne devons pas déclarer la taille du tableau lorsque nous fournissons les éléments du tableau.

29) Qu'est-ce que le tableau bidimensionnel ?

Un tableau d'un tableau en Java. Nous pouvons les déclarer comme
int[][] p = new int[3][3]
qui est une matrice de 3×3.

30) Avons-nous des tableaux tridimensionnels en Java ?

Oui, Java prend en charge les tableaux à N dimensions. Un tableau multidimensionnel en Java n'est rien d'autre qu'un tableau de tableaux, Exemple : un tableau à 2 dimensions est un tableau de tableau à 1 dimension.

31) Pouvons-nous rendre un tableau volatile en Java ?

Oui, nous pouvons rendre un tableau volatil en Java, mais nous ne rendons volatile que la variable qui pointe vers le tableau.

32) Quel sera le résultat du code ci-dessous ?

int myArr[] = new int [7];

System.out.print(myArr);
Réponse : La sortie sera la valeur Garbage. myArr est une variable tableau, myArr pointe vers un tableau s'il s'agit d'entiers. L'impression de myArr imprimera la valeur des déchets. Ce n'est pas la même chose que d'imprimer myArr[0].

33) Quelle est l'étape pour accéder aux éléments d'un tableau en Java ?

Nous pouvons y accéder en utilisant « index ». L'index commence à zéro (0), donc le premier élément est stocké à l'emplacement zéro et le dernier élément sera Array.length – 1. Exemple:- String strArr[] = new String []{"A", "B", "C", "D", "E"}; strArr[0] signifie « A » et strArr[2] signifie « C ».

34) Pouvez-vous me dire les différences entre Array et ArrayList ?

tableau ArrayList
Le tableau est statique avec une taille fixe qui ne peut pas être modifiée une fois supprimée. ArrayList n’est pas de taille statique mais dynamique. À mesure que des éléments sont ajoutés à une ArrayList, sa capacité ou sa taille augmente automatiquement.
Il contient à la fois des types de données primitifs et des objets d'une classe. ArrayList ne contient pas les types de données primitifs mais contient des entrées d'objet.
La baie n'a pas de fonctionnalité générique. ArayList a une fonctionnalité générique.

35) Nous savons que les tableaux sont des objets, alors pourquoi ne pouvons-nous pas écrire strArray.length() ?

Les tableaux sont des références d'objets comme les classes en Java. Nous pouvons utiliser les méthodes d'Object comme toString () et une autre hashCode () contre Array. La longueur est un élément de données d’un tableau et ce n’est donc pas une méthode. C'est pourquoi nous utilisons strArray.length.

36) Comment trouver l'élément manquant dans un tableau d'entiers de 1 à 7 ?

Les solutions pour résoudre ce problème consistent à calculer la somme de tous les nombres du tableau et à comparer avec une somme attendue, la différence serait le nombre manquant.
int ar [] = new int[]{1,2,3,5,6,7};
  • Obtenez la somme des nombres
  • total = n*(n+1)/2
  • Soustrayez tous les nombres de la somme et
  • vous obtiendrez le numéro manquant.
  • Selon la logique ci-dessous, sumOfNnumberss est 7*(7+1)/2=28
sumOfElements = 1+2+3+5+6+7=24 l'élément manquant est = 28-24=4
int n = ar.length+1;

int total = n*(n+1)/2;

for(int i =0;i<ar.length;i++){

total -=ar[i];}

System.out.println(total);

37) Comment trouver le doublon dans un tableau ?

String str = "HI RAHUL I AM FINE RAHUL"; // String with a duplicate word.

String[] words = str.split(" "); // Splitting and converting to Array .

for(int i = 0; i < words.length; i++){ //iterating array inside for loop

for(int j = i+1; j < words.length; j++){ //iterating same array inside another for loop

if (words[i].equals(words[j])){ // Using equal method i am verifying which word is repeating . System.out.println( words[i]); // here it will print duplicate .

}}}

38) Comment vérifier que le tableau contient une valeur ou non ?

Voici une String[] avec des valeurs
public static final String[] myNames = new String[] {"B","A","K","C"};
Si myNames contient cette valeur, il renverra true sinon false. Voici deux méthodes isExists() et contain(), les deux méthodes renvoient true si la valeur est disponible, sinon false. Première méthode Il convertit un tableau en ArrayList. Après cela, il testera si un tableau contient une valeur, puis il retournera vrai, sinon faux.
public static <T> boolean isExists(final T[] array, final T object) {

return Arrays.asList(array).contains(object); }
Deuxième méthode Cette méthode parcourt un tableau et utilise la méthode equal() pour rechercher un élément. Cela effectue en fait une recherche linéaire sur un tableau en Java. Il retournera vrai si un tableau a fourni une valeur.
public static <T> boolean contains(final T[] array, final T v) {

for (final T e : array) { if (e == v || v != null && v.equals(e)) {

return true;

} }

return false;

} }

39) Comment obtenir le plus grand et le plus petit nombre dans un tableau ?

Réponse : Logique de ce problème :
  • Nous utilisons deux variables pour stocker le plus grand et le plus petit nombre.
  • Tout d’abord, nous initialisons le plus grand avec Integer.MIN_VALUE et
  • Ensuite, nous initialisons le plus petit avec Integer.MAX_VALUE.
  • À chaque itération de la boucle for, nous comparerons le nombre actuel avec le nombre le plus grand et le plus petit, et nous mettrons à jour
  • Si un nombre est supérieur au plus grand, il ne peut pas être inférieur au plus petit. Cela signifie qu'il n'est pas nécessaire de vérifier si la première condition est vraie,
  • Nous utiliserons le bloc de code if-else, où la partie else ne s'exécutera que si la première condition est fausse, ce qui signifie qu'elle n'est pas vraie.
import java.util.Arrays;

public class MaximumMinimumArrayExample{

public static void largestAndSmallest(int[] numbers) {

int largest = Integer.MIN_VALUE;

int smallest = Integer.MAX_VALUE;

for (int number : numbers) {

if (number > largest) {

largest = number;

}

else if (number < smallest) {

smallest = number;

} }
System.out.println("Largest is : " + largest);

System.out.println("Smallest is : " + smallest); } }

40) Comment faire l'intersection de deux tableaux triés ?

Réponse : Logique : imprime l'élément si l'élément est présent ou disponible dans les deux tableaux.
  • Utilisez deux variables d'index i et j, puis initialisez les valeurs i = 0, j = 0
  • Si arr01 [i] est plus petit que arr02 [j] alors incrémentez i.
  • Si arr01 [i] est supérieur à arr02 [j], alors incrémentez j.
  • Si les deux sont identiques, imprimez-en un et incrémentez i et j.
public static void getIntersection(int arr01[], int arr02[], int m, int n){

int i = 0, j = 0;

while (i < m && j < n){

if (arr01[i] < arr02[j])

i++;

else if (arr02[j] < arr01[i])

j++;

else{

System.out.print(arr02[j++]+" ");

i++;

}

}

}

public static void main(String args[]){

int arr01[] = {1, 2, 4, 5, 6};

int arr02[] = {2, 3, 5, 7};

int m = arr01.length;

int n = arr02.length;

getIntersection(arr01, arr02, m, n);

}

41) Comment obtenir les deux premiers nombres d’un tableau ?

Réponse : La logique est :
  • Nous attribuerons la première variable max01 avec Integer.MIN_VALUE
De plus, la deuxième variable max02 est identique à max01, c'est-à-dire Integer.MIN_VALUE.
  • Nous allons parcourir ce tableau et comparer chaque nombre avec max01 et max02,
  • Si le nombre actuel est supérieur à max1, attribuez max01 = nombre et max02 = max1.
  • Sinon, s'il est seulement supérieur à max02, nous ne mettrons à jour max02 qu'avec le nombre actuel.
  • À la fin d'une itération, max01 et max02 pointent vers les deux premiers nombres d'un tableau donné.
import java.util.Arrays;

public class TopTwoMaximumNumbers{

public static void main(String args[]) {

topTwoNumbers(new int[]{20, 34, 21, 87, 92, Integer.MAX_VALUE});

topTwoNumbers(new int[]{0, Integer.MIN_VALUE, -2});

topTwoNumbers(new int[]{Integer.MAX_VALUE, 0, Integer.MAX_VALUE});

topTwoNumbers(new int[]{1, 1, 0}); }

public static void topTwoNumbers(int[] numbers) {

int max01 = Integer.MIN_VALUE;

int max02 = Integer.MIN_VALUE; for (int number : numbers) {

if (number > max01) { max02 = max01; max01 = number; }

else if (number > max02) { max02 = number; } }

System.out.println("First largest number is : " + max01);

System.out.println("Second largest number is : " + max02); } }

42) Comment couper ou supprimer un élément du tableau ?

Réponse : La logique est la suivante : nous pouvons supprimer ou couper un élément à l'aide d'Apache Commons ArrayUtils basé sur un index. ArrayUtils a plusieurs méthodes Remove() surchargées.
import java.util.Arrays;

import org.apache.commons.lang.ArrayUtils;

public class RemoveFromArray{

public static void main(String args[]) {

//let's create an array for demonstration purpose

int[] testArr = new int[] { 10, 102, 13, 14, 105};

System.out.println("Array size : " + testArr.length );

System.out.println("Find Contents : " + Arrays.toString(testArr));

//let's remove or delete an element from Array using Apache Commons ArrayUtils

testArr = ArrayUtils.remove(testArr, 2); //removing element at index 2

//Size of array must be 1 less than original array after deleting an element

System.out.println("Size of array after removing : " + testArr.length);

System.out.println("Content of Array : "+ Arrays.toString(testArr));

} }

43) Quelle est la logique pour inverser le tableau ?

Réponse : Logique : imprimez l'élément dans l'ordre inverse.
  • Déclarer un
String Array String[] s = new String[]{"My","Leg","is","cut"};
  • Itérez-le en utilisant la boucle for pour obtenir tous les éléments dans l'ordre inverse, ce qui signifie du point final au point de départ.
public static void main(String[] args)

{String[] s = new String[]{"My","Leg","is","cut"};

for(int i=s.length-1; i>=0; i--){

System.out.println("reverse "+s[i]);}}

44) Comment trouve-t-on le deuxième plus grand élément d'un tableau d'entiers ?

Réponse : La logique est :
  • Itérer le tableau donné en utilisant la boucle for.
  • (premier si condition arr[i] > plus grand) :
  • Si la valeur actuelle du tableau est supérieure à la plus grande valeur, alors
  • Déplacez la plus grande valeur vers la seconde plus grande et faites de la valeur actuelle la plus grande
  • (seconde si condition arr[i] > secondLargest )
  • Si la valeur actuelle est inférieure à la plus grande et
supérieur à secondLargest alors la valeur actuelle devient
public static void main(String[] args) {

int myArr[] = { 14, 46, 47, 86, 92, 52, 48, 36, 66, 85 };

int largest = myArr[0];

int secondLargest = myArr[0];

System.out.println("The given array is:" );

for (int i = 0; i < myArr.length; i++) {

System.out.print(myArr[i]+"\t");

}

for (int i = 0; i < myArr.length; i++) {

if (myArr[i] > largest) {

secondLargest = largest;

largest = myArr[i];

} else if (myArr[i] > secondLargest) {secondLargest = myArr[i];

}}

System.out.println("\nSecond largest number is:" + secondLargest);

}

45) Écrivez un programme pour additionner les valeurs d'un tableau donné.

Réponse : La logique est :
  • Déclarez et attribuez une variable int dont la somme est =0.
  • Itérer le tableau donné en utilisant la boucle for.
  • Ajoutez tous les éléments du tableau et conservez dans cette variable qui est la somme.
Public static void main(String[] args) {

int my_array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int sum = 0;

for (int i: my_array)

sum += i;

System.out.println("The sum is " + sum);

}

46) Comment séparer les zéros des non-zéros dans un tableau ?

Réponse : La logique est :
  • Initialisation du compteur à 0
  • Traversée d'inputArray de gauche à droite
  • Si inputArray[i] est différent de zéro
  • Affectation de inputArray[i] à inputArray[counter]
  • Incrémenter le compteur de 1
  • Attribuer zéro aux éléments restants
Public class SeparateZerosFromNonZeros

{ static void moveZerosToEnd(int inputArray[]) { int counter = 0;

for (int i = 0; i < inputArray.length; i++)

{

if(inputArray[i] != 0) {

inputArray[counter] = inputArray[i];

counter++;

} }

while (counter < inputArray.length) {

inputArray[counter] = 0;

counter++; }

System.out.println(Arrays.toString(inputArray));

}

public static void main(String[] args) {

moveZerosToEnd(new int[] {12, 0, 7, 0, 8, 0, 3});

moveZerosToEnd(new int[] {1, -5, 0, 0, 8, 0, 1});

moveZerosToEnd(new int[] {0, 1, 0, 1, -5, 0, 4});

moveZerosToEnd(new int[] {-4, 1, 0, 0, 2, 21, 4});

} }

47) Écrire un programme pour insérer un élément et à une position spécifique dans le tableau ?

Réponse : La logique est :
  • Insérer un élément en 3ème position du tableau (index->2, valeur->5)
  • Parcourez le tableau donné dans l’ordre inverse en utilisant la boucle for.
  • Insérez maintenant la position et la valeur données après la boucle for.
Public static void main(String[] args) {

int[] my_array = {25, 14, 56, 15, 36, 56, 77, 18, 29, 49};

int Index_position = 2;

int newValue = 5;

System.out.println("Original Array : "+Arrays.toString(my_array));

for(int i=my_array.length-1; i > Index_position; i--){

my_array[i] = my_array[i-1];
}my_array[Index_position] = newValue;

System.out.println("New Array: "+Arrays.toString(my_array));

}

48) Comment obtenir l'index d'un élément d'un tableau ?

Réponse : La logique est :
  • À chaque étape, il vérifie la valeur de la clé d'entrée avec la valeur de l'élément central d'un tableau.
  • Si les clés correspondent, la position sera renvoyée. Dans un autre cas, si la clé est inférieure à la clé de l'élément du milieu,
  • Ensuite, il répétera la boucle while. Si le tableau restant recherché et réduit à zéro, il renverra -1 signifie introuvable
public static int findIndex (int[] my_array, int t) {

int startPoint = 0;

int endPoint = my_array.length - 1;

while (startPoint <= endPoint) {

int mid = (startPoint + end) / 2;

if (key == my_array[mid]) {

return mid;

}

if (key < my_array[mid]) {

endPoint = mid - 1;
} else {

startPoint = mid + 1;

}

}

return -1;

}

Public static void main(String[] args) {

int[] arr = {2, 4, 6, 8, 10, 12, 14, 16};

System.out.println("Key 14's position: "findIndex(arr, 14));

int[] arr1 = {6,34,78,123,432,900};

System.out.println("Key 432's position: "+findIndex(arr1, 432));

}

49 Pouvons-nous étendre un tableau après l'initialisation ?

Réponse : La logique est la suivante : nous pouvons étendre un tableau après l'initialisation en ajoutant un nouveau tableau. Veuillez trouver ci-dessous un exemple.
Public static void main(String[] args) {

String [] names = new String[] { "A", "B", "C" };

String [] extended = new String[5];

extended [3] = "D";

extended [4] = "E";

System.arraycopy(names, 0, extended, 0, names.length);

//here we are extending with new array extended[3] and extended[4].

for (String str: extended){

System.out.println(str);

}

}
la sortie est A,B,C,D,E.

50) Comment remplir un élément (initialiser immédiatement) dans un tableau ?

Réponse : Cet exemple remplit (initialise tous les éléments du tableau en un seul court) un tableau en utilisant la méthode Array.fill (nom du tableau, valeur) et Array.fill (nom du tableau, index de départ, index de fin, valeur) la méthode de Classe Utilitaire Java.
import java.util.*;

public class FillTest {

public static void main(String args[]) {

int array[] = new int[6];

Arrays.fill(array, 100);

for (int i = 0, n = array.length; i < n; i++) {

System.out.println(array[i]);

}

System.out.println();

Arrays.fill(array, 3, 6, 50);

for (int i = 0, n = array.length; i< n; i++) {

System.out.println(array[i]);}}}
la sortie est
100,100,100,100,100,100

100,100,100,50,50,50
Partager

2 Commentaires

  1. Qu'en est-il du passage d'un tableau en tant que paramètres aux fonctions ?

  2. Avatar Arymanu Singh dit:

    Q14 différence entre a[] et []a

    Après la première déclaration de type, vous ne pouvez pas créer un autre tableau (même type de données).
    Mais vous pouvez le faire après la déclaration du deuxième type, c'est-à-dire.
    Int []a, b, c= nouveau int[taille]

Laissez un commentaire

Votre adresse email n'apparaitra pas. Les champs obligatoires sont marqués *