Mis à part la boucle dans chaque élément d'un tableau et la définition de chacun comme null, existe-t-il une fonction native dans Java/processing pour vider simplement un tableau (ou le détruire, pour pouvoir le redéclarer comme nouveau tableau)?
Il y a
Arrays.fill(myArray, null);
Cela ne veut pas dire que vous ne fassiez pas autre chose que vous le fassiez vous-même (il passe en boucle à travers chaque élément et le définit sur null). Ce n’est pas natif, c’est du code purement Java qui effectue cela, mais c’est une est fonction de bibliothèque si c'est peut-être ce que vous vouliez dire.
Bien sûr, cela ne vous permet pas de redimensionner le tableau (à zéro), si c'est ce que vous entendiez par "Vide". Les tailles de tableau étant fixes, si vous voulez que le "nouveau" tableau ait différentes dimensions, il est préférable de réaffecter la référence à un nouveau tableau, comme le montrent les autres réponses. Mieux encore, utilisez un type List
comme ArrayList
qui peut avoir une taille variable.
Vous pouvez simplement affecter null
à la référence. (Cela fonctionnera pour tout type de tableau, pas seulement ints
)
int[] arr = new int[]{1, 2, 3, 4};
arr = null;
Cela "efface" le tableau. Vous pouvez également affecter un nouveau tableau à cette référence si vous aimez:
int[] arr = new int[]{1, 2, 3, 4};
arr = new int[]{6, 7, 8, 9};
Si vous craignez des fuites de mémoire, ne le soyez pas. Le ramasse-miettes nettoie toutes les références laissées par le tableau.
Un autre exemple:
float[] arr = ;// some array that you want to clear
arr = new float[arr.length];
Cela créera un nouveau float[]
initialisé à la valeur par défaut pour float.
array = new String[array.length];
Si Array xco
n'est pas final, une simple réaffectation fonctionnerait:
c'est à dire.
xco = new Float[xco .length];
Cela suppose que vous avez besoin du tableau xco
pour conserver la même taille. Si cela n'est pas nécessaire, créez un tableau vide:
xco= new Float[0];
Cela se fait plus rapidement qu'avec Arrays.fill (From Fast Serialization Lib). Je viens d'utiliser arrayCopy (est natif) pour effacer le tableau:
static Object[] EmptyObjArray = new Object[10000];
public static void clear(Object[] arr) {
final int arrlen = arr.length;
clear(arr, arrlen);
}
public static void clear(Object[] arr, int arrlen) {
int count = 0;
final int length = EmptyObjArray.length;
while( arrlen - count > length) {
System.arraycopy(EmptyObjArray,0,arr,count, length);
count += length;
}
System.arraycopy(EmptyObjArray,0,arr,count, arrlen -count);
}
Prenons par exemple le tableau double, si le tableau values
d'entrée initial est pas vide , le fragment de code suivant est supérieur au for-loop
direct traditionnel en complexité temporelle:
public static void resetValues(double[] values) {
int len = values.length;
if (len > 0) {
values[0] = 0.0;
}
for (int i = 1; i < len; i += i) {
System.arraycopy(values, 0, values, i, ((len - i) < i) ? (len - i) : i);
}
}
Je veux juste ajouter quelque chose au commentaire de Mark. Si vous souhaitez réutiliser un tableau sans allocation supplémentaire, utilisez-le à nouveau et remplacez les valeurs existantes par de nouvelles. Cela fonctionnera si vous remplissez le tableau séquentiellement. Dans ce cas, rappelez-vous simplement du dernier élément initialisé et utilisez un tableau jusqu'à cet index. Peu importe qu’il y ait des ordures à la fin du tableau.
J'ai pu le faire avec les 2 lignes suivantes, j'avais un tableau appelé selected_items utilisé pour obtenir tous les éléments sélectionnés sur un dataTable
selected_items = null;
selected_items = [];