Taille de tableau dynamic Java?

J’ai une classe – xClass, que je veux charger dans un tableau de xClass alors je la déclaration:

xClass mysclass[] = new xClass[10]; myclass[0] = new xClass(); myclass[9] = new xClass(); 

Cependant, je ne sais pas si j’aurai besoin de 10. Je pourrais avoir besoin de 8 ou 12 ou de tout autre nombre. Je ne saurai pas jusqu’à l’exécution. Puis-je modifier le nombre d’éléments d’un tableau à la volée? Si c’est le cas, comment?

Non, vous ne pouvez pas modifier la taille d’un tableau une fois créé. Vous devez soit l’allouer plus important que vous ne le croyez ou accepter de devoir le réaffecter pour augmenter sa taille. Lorsque c’est le cas, vous devrez en allouer un nouveau et copier les données de l’ancien vers le nouveau:

 int oldItems[] = new int[10]; for (int i=0; i<10; i++) { oldItems[i] = i+10; } int newItems[] = new int[20]; System.arraycopy(oldItems, 0, newItems, 0, 10); oldItems = newItems; 

Si vous vous trouvez dans cette situation, je vous recommande fortement d'utiliser les collections Java à la place. En particulier, ArrayList essentiellement un tableau et prend en charge la logique de croissance du tableau selon les besoins:

 List mysclass = new ArrayList(); myclass.add(new xClass()); myclass.add(new xClass()); 

De manière générale, ArrayList est une solution préférable à un tableau pour plusieurs raisons. D'une part, les tableaux sont mutables. Si vous avez une classe qui fait cela:

 class Myclass { private int items[]; public int[] getItems() { return items; } } 

Vous avez créé un problème car un appelant peut modifier votre membre de données privé, ce qui entraîne toutes sortes de copies défensives. Comparez ceci à la version de liste:

 class Myclass { private List items; public List getItems() { return Collections.unmodifiableList(items); } } 

En java, la longueur du tableau est fixe.

Vous pouvez utiliser une liste pour contenir les valeurs et appeler la méthode toArray si nécessaire. Voir l’exemple suivant:

 import java.util.List; import java.util.ArrayList; import java.util.Random; public class A { public static void main( Ssortingng [] args ) { // dynamically hold the instances List list = new ArrayList(); // fill it with a random number between 0 and 100 int elements = new Random().nextInt(100); for( int i = 0 ; i < elements ; i++ ) { list.add( new xClass() ); } // convert it to array xClass [] array = list.toArray( new xClass[ list.size() ] ); System.out.println( "size of array = " + array.length ); } } class xClass {} 

Comme d’autres l’ont déjà dit, vous ne pouvez pas modifier la taille d’un tableau Java existant.

ArrayList est le plus proche de Java standard à un tableau de taille dynamic. Cependant, il y a des choses à propos de ArrayList (en fait, l’interface de liste) qui ne sont pas “comme un tableau”. Par exemple:

  • Vous ne pouvez pas utiliser [ ... ] pour indexer une liste. Vous devez utiliser les méthodes get(int) et set(int, E) .
  • Un ArrayList est créé avec zéro élément. Vous ne pouvez pas simplement créer une ArrayList avec 20 éléments, puis appeler set(15, foo) .
  • Vous ne pouvez pas modifier directement la taille d’un ArrayList. Vous le faites indirectement en utilisant les différentes méthodes d’ add , d’ insert et de remove .

Si vous voulez quelque chose de plus semblable à un tableau, vous devrez concevoir votre propre API. (Peut-être que quelqu’un pourrait utiliser une bibliothèque tierce existante … Je n’ai pas pu en trouver une avec 2 minutes de “recherche” en utilisant Google :-))

Si vous avez seulement besoin d’un tableau qui grandit à mesure que vous l’initialisez , la solution est quelque chose comme ça.

 ArrayList tmp = new ArrayList(); while (...) { tmp.add(new T(...)); } // This creates a new array and copies the element of 'tmp' to it. T[] array = tmp.toArray(new T[tmp.size()]); 

Vous définissez le nombre d’éléments à tout ce que vous voulez au moment de sa création:

 xClass[] mysclass = new xClass[n]; 

Ensuite, vous pouvez initialiser les éléments dans une boucle. Je suppose que c’est ce dont vous avez besoin.

Si vous devez append ou supprimer des éléments dans le tableau après l’avoir créé, vous devrez utiliser une liste de ArrayList .

Vous pouvez utiliser ArrayList:

 import java.util.ArrayList; import java.util.Iterator; 

 ArrayList arr = new ArrayList(); arr.add("neo"); arr.add("morpheus"); arr.add("sortingnity"); Iterator foreach = arr.iterator(); while (foreach.hasNext()) System.out.println(foreach.next()); 

Oui, emballez-le et utilisez le cadre Collections.

 List l = new ArrayList(); l.add(new xClass()); // do stuff l.add(new xClass()); 

Utilisez ensuite List.toArray () si nécessaire, ou simplement parcourez cette liste.

Comme d’autres utilisateurs le disent, vous avez probablement besoin d’une implémentation de java.util.List.

Si, pour une raison quelconque, vous avez finalement besoin d’un tableau, vous pouvez faire deux choses:

  • Utilisez une liste, puis convertissez-la en tableau avec myList.toArray ()

  • Utilisez un tableau d’une certaine taille. Si vous avez besoin de plus ou de moins de taille, vous pouvez le modifier avec les méthodes java.util.Arrays.

La meilleure solution dépendra de votre problème;)

Je recommande d’utiliser plutôt des vecteurs. Très facile à utiliser et dispose de nombreuses méthodes prédéfinies pour la mise en œuvre.

 import java.util.*; Vector v=new Vector(5,2); 

pour append un élément, utilisez simplement:

 v.addElement(int); 

Dans le (5,2) le premier 5 est la taille initiale du vecteur. Si vous dépassez la taille initiale, le vecteur se développera de 2 places. S’il dépasse à nouveau, il augmentera encore de 2 places et ainsi de suite.

Arrays.copyOf() méthode Arrays.copyOf() dispose de nombreuses options pour résoudre le problème, la longueur du tableau augmentant de manière dynamic.

API Java

Où vous déclarez le tableau myclass [] comme:

 xClass myclass[] = new xClass[10] 

, passez simplement en argument le nombre d’éléments XClass dont vous aurez besoin. À ce stade, savez-vous combien vous aurez besoin? En déclarant le tableau comme ayant 10 éléments, vous ne déclarez pas 10 objects XClass, vous créez simplement un tableau avec 10 éléments de type xClass.

C’est une bonne pratique pour obtenir le montant dont vous avez besoin pour stocker en premier, puis initialiser le tableau.

Par exemple, vous demandez à l’utilisateur combien de données il doit stocker, puis initialiser, ou interroger le composant ou l’argument sur le nombre de données à stocker. Si vous voulez un tableau dynamic, vous pouvez utiliser ArrayList() et utiliser al.add(); fonction pour continuer à append, alors vous pouvez le transférer à un tableau fixe.

 //Initialize ArrayList and cast ssortingng so ArrayList accepts ssortingngs (or anything ArrayList al = new ArrayList(); //add a certain amount of data for(int i=0;i 

faire ainsi est redondant mais juste pour vous montrer l'idée, ArrayList peut contenir des objects contrairement à d'autres types de données primitifs et est très facile à manipuler, en supprimant tout ce qui est au milieu, complètement dynamic.same avec List et Stack

Les tailles de Java Array sont fixes. Vous ne pouvez pas créer de tableaux dynamics en C ++.

Je ne sais pas si vous pouvez modifier la taille lors de l’exécution, mais vous pouvez allouer la taille à l’exécution. Essayez d’utiliser ce code:

 class MyClass { void myFunction () { Scanner s = new Scanner (System.in); int myArray []; int x; System.out.print ("Enter the size of the array: "); x = s.nextInt(); myArray = new int[x]; } } 

cela affecte la taille de votre tableau à celle entrée au moment de l’exécution dans x.

Voici une méthode qui n’utilise pas ArrayList. L’utilisateur spécifie la taille et vous pouvez append une boucle do-all pour la récursivité.

 import java.util.Scanner; public class Dynamic { public static Scanner value; public static void main(Ssortingng[]args){ value=new Scanner(System.in); System.out.println("Enter the number of tests to calculate average\n"); int limit=value.nextInt(); int index=0; int [] marks=new int[limit]; float sum,ave; sum=0; while(index 

Dans Java Array, les tailles sont toujours de longueur fixe. Cependant, il existe un moyen d’augmenter dynamicment la taille du tableau au moment de l’exécution.

C’est la manière la plus “utilisée” et préférée de le faire –

  int temp[]=new int[stck.length+1]; for(int i=0;i 

Dans le code ci-dessus, nous initialisons un nouveau tableau temp [], et nous utilisons une boucle for pour initialiser le contenu du temp avec le contenu du tableau d'origine. stck []. Et puis, encore une fois, en le recopiant à l’original, nous donnant un nouveau tableau de la nouvelle taille.

Il ne fait aucun doute qu'il génère une surcharge de processeur en raison de la réinitialisation d'un tableau utilisant for loop plusieurs fois. Mais vous pouvez toujours l'utiliser et l'implémenter dans votre code. Pour la meilleure pratique, utilisez "Liste liée" au lieu de Array, si vous souhaitez que les données soient stockées dynamicment dans la mémoire, de longueur variable.

Voici un exemple en temps réel basé sur des stacks dynamics pour AUGMENTER LA TAILLE DE L'ARRAY au moment de l'exécution

Nom de fichier: DStack.java

 public class DStack { private int stck[]; int tos; void Init_Stck(int size) { stck=new int[size]; tos=-1; } int Change_Stck(int size){ return stck[size]; } public void push(int item){ if(tos==stck.length-1){ int temp[]=new int[stck.length+1]; for(int i=0;i 

Nom du fichier: Exec.java
(avec la classe principale)

 import java.util.*; public class Exec { private static Scanner in; public static void main(Ssortingng[] args) { in = new Scanner(System.in); int option,item,i=1; DStack obj=new DStack(); obj.Init_Stck(1); do{ System.out.println(); System.out.println("--MENU--"); System.out.println("1. Push a Value in The Stack"); System.out.println("2. Pop a Value from the Stack"); System.out.println("3. Display Stack"); System.out.println("4. Exit"); option=in.nextInt(); switch(option){ case 1: System.out.println("Enter the Value to be Pushed"); item=in.nextInt(); obj.push(item); break; case 2: System.out.println("Popped Item: "+obj.pop()); obj.Change_Stck(obj.tos); break; case 3: System.out.println("Displaying..."); obj.display(); break; case 4: System.out.println("Exiting..."); i=0; break; default: System.out.println("Enter a Valid Value"); } }while(i==1); } } 

J'espère que cela résout votre requête.

Oui, nous pouvons faire comme ça.

 import java.util.Scanner; public class Collection_Basic { private static Scanner sc; public static void main(Ssortingng[] args) { Object[] obj=new Object[4]; sc = new Scanner(System.in); //Storing element System.out.println("enter your element"); for(int i=0;i<4;i++){ obj[i]=sc.nextInt(); } /* * here, size reaches with its maximum capacity so u can not store more element, * * for storing more element we have to create new array Object with required size */ Object[] tempObj=new Object[10]; //copying old array to new Array int oldArraySize=obj.length; int i=0; for(;i 

Comme ArrayList prend beaucoup de mémoire lorsque j’ai besoin d’un tableau de types primitifs, je préfère utiliser IntStream.builder () pour créer un tableau int (vous pouvez également utiliser les générateurs LongStream et DoubleStream).

Exemple:

 Builder builder = IntStream.builder(); int arraySize = new Random().nextInt(); for(int i = 0; i 

Remarque: disponible depuis Java 8.

Vous pouvez faire quelque chose

 private static Person [] addPersons(Person[] persons, Person personToAdd) { int currentLenght = persons.length; Person [] personsArrayNew = Arrays.copyOf(persons, currentLenght +1); personsArrayNew[currentLenght] = personToAdd; return personsArrayNew; }