Comment ajouter de nouveaux éléments à un tableau?
J'ai le code suivant:
String[] where;
where.append(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.append(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");
Ces deux annexes ne sont pas en train de compiler. Comment cela fonctionnerait-il correctement?
La taille d'un tableau ne peut pas être modifiée. Si vous voulez un plus grand tableau, vous devez en instancier un nouveau.
Une meilleure solution consisterait à utiliser un ArrayList qui peut évoluer à mesure que vous en avez besoin. La méthode ArrayList.toArray( T[] a ) vous restitue votre tableau si vous en avez besoin sous cette forme.
List<String> where = new ArrayList<String>();
where.add( ContactsContract.Contacts.HAS_PHONE_NUMBER+"=1" );
where.add( ContactsContract.Contacts.IN_VISIBLE_GROUP+"=1" );
Si vous avez besoin de le convertir en un simple tableau ...
String[] simpleArray = new String[ where.size() ];
where.toArray( simpleArray );
Mais la plupart des choses que vous faites avec un tableau que vous pouvez faire avec cet ArrayList aussi:
// iterate over the array
for( String oneItem : where ) {
...
}
// get specific items
where.get( 1 );
Utilisez un List<String> , tel qu'un ArrayList<String> . Il est évolutif de manière dynamique, contrairement aux tableaux (voir: Effective Java 2e édition, élément 25: Préférer les listes aux tableaux ).
_import Java.util.*;
//....
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
System.out.println(list); // prints "[1, 2, 3]"
_Si vous insistez pour utiliser des tableaux, vous pouvez utiliser Java.util.Arrays.copyOf pour allouer un tableau plus grand pour accueillir l'élément supplémentaire. Ce n'est vraiment pas la meilleure solution, cependant.
_static <T> T[] append(T[] arr, T element) {
final int N = arr.length;
arr = Arrays.copyOf(arr, N + 1);
arr[N] = element;
return arr;
}
String[] arr = { "1", "2", "3" };
System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3]"
arr = append(arr, "4");
System.out.println(Arrays.toString(arr)); // prints "[1, 2, 3, 4]"
_Ceci est O(N) par append. ArrayList a par contre O(1) coût amorti par opération.
Voir également
- Tutoriels/Tableaux Java
- Un tableau est un objet conteneur qui contient un nombre fixe de valeurs d'un seul type. La longueur d'un tableau est établie lors de sa création. Après création, sa longueur est fixée.
- Tutoriels Java/Interface Liste
Apache Commons Lang a
T[] t = ArrayUtils.add( initialArray, newitem );
elle retourne un nouveau tableau, mais si vous travaillez réellement avec des tableaux pour une raison quelconque, c'est peut-être le moyen idéal de le faire.
Il existe une autre option que je n'ai pas vue ici et qui n'implique pas d'objets ou de collections "complexes".
String[] array1 = new String[]{"one", "two"};
String[] array2 = new String[]{"three"};
String[] array = new String[array1.length + array2.length];
System.arraycopy(array1, 0, array, 0, array1.length);
System.arraycopy(array2, 0, array, array1.length, array2.length);
Il n'y a pas de méthode append() sur les tableaux. Comme déjà suggéré, un objet List peut répondre au besoin d'insérer dynamiquement des éléments, par exemple.
List<String> where = new ArrayList<String>();
where.add(ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1");
where.add(ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1");
Ou si vous souhaitez vraiment utiliser un tableau:
String[] where = new String[]{
ContactsContract.Contacts.HAS_PHONE_NUMBER + "=1",
ContactsContract.Contacts.IN_VISIBLE_GROUP + "=1"
};
mais alors ceci est une taille fixe et aucun élément ne peut être ajouté.
String[] source = new String[] { "a", "b", "c", "d" };
String[] destination = new String[source.length + 2];
destination[0] = "/bin/sh";
destination[1] = "-c";
System.arraycopy(source, 0, destination, 2, source.length);
for (String parts : destination) {
System.out.println(parts);
}
Comme Tangens l'a dit, la taille d'un tableau est fixe. Mais vous devez d'abord l'instancier, sinon ce ne sera qu'une référence nulle.
String[] where = new String[10];
Ce tableau ne peut contenir que 10 éléments. Vous pouvez donc ajouter une valeur seulement 10 fois. Dans votre code, vous accédez à une référence nulle. C'est pourquoi cela ne fonctionne pas. Pour avoir une collection en croissance dynamique, utilisez ArrayList.
Vous devez utiliser une liste de collections. Vous ne pouvez pas redimensionner un tableau.
Il y a plusieurs façons d'ajouter un élément à un tableau. Vous pouvez utiliser un temp List pour gérer l'élément, puis le reconvertir en Array ou vous pouvez utiliser le Java.util.Arrays.copyOf et le combiner avec des génériques pour obtenir de meilleurs résultats.
Cet exemple va vous montrer comment:
public static <T> T[] append2Array(T[] elements, T element)
{
T[] newArray = Arrays.copyOf(elements, elements.length + 1);
newArray[elements.length] = element;
return newArray;
}
Pour utiliser cette méthode, il vous suffit de l'appeler comme suit:
String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, "four");
System.out.println(Arrays.toString(numbers));
Si vous voulez fusionner deux tableaux, vous pouvez modifier la méthode précédente comme ceci:
public static <T> T[] append2Array(T[] elements, T[] newElements)
{
T[] newArray = Arrays.copyOf(elements, elements.length + newElements.length);
System.arraycopy(newElements, 0, newArray, elements.length, newElements.length);
return newArray;
}
Maintenant, vous pouvez appeler la méthode comme ceci:
String[] numbers = new String[]{"one", "two", "three"};
String[] moreNumbers = new String[]{"four", "five", "six"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(numbers, moreNumbers);
System.out.println(Arrays.toString(numbers));
Comme je l'ai mentionné, vous pouvez également utiliser des objets List. Cependant, il faudra un peu de bidouillage pour le mettre en sécurité comme ceci:
public static <T> T[] append2Array(Class<T[]> clazz, List<T> elements, T element)
{
elements.add(element);
return clazz.cast(elements.toArray());
}
Maintenant, vous pouvez appeler la méthode comme ceci:
String[] numbers = new String[]{"one", "two", "three"};
System.out.println(Arrays.toString(numbers));
numbers = append2Array(String[].class, Arrays.asList(numbers), "four");
System.out.println(Arrays.toString(numbers));
Ajout de nouveaux éléments au tableau String.
String[] myArray = new String[] {"x", "y"};
// Convert array to list
List<String> listFromArray = Arrays.asList(myArray);
// Create new list, because, List to Array always returns a fixed-size list backed by the specified array.
List<String> tempList = new ArrayList<String>(listFromArray);
tempList.add("z");
//Convert list back to array
String[] tempArray = new String[tempList.size()];
myArray = tempList.toArray(tempArray);
Si vous souhaitez stocker vos données dans un tableau simple comme celui-ci
String[] where = new String[10];
et vous voulez ajouter des éléments comme des nombres, merci de nous donner StringBuilder, qui est beaucoup plus efficace que la concaténation de chaînes.
StringBuilder phoneNumber = new StringBuilder();
phoneNumber.append("1");
phoneNumber.append("2");
where[0] = phoneNumber.toString();
C'est une méthode bien meilleure pour construire votre chaîne et la stocker dans votre tableau 'where'.
J'ai fait ce code! Il fonctionne comme un charme!
public String[] AddToStringArray(String[] oldArray, String newString)
{
String[] newArray = Arrays.copyOf(oldArray, oldArray.length+1);
newArray[oldArray.length] = newString;
return newArray;
}
J'espère que tu aimes!!
Je n'ai pas l'expérience de Java, mais on m'a toujours dit que les tableaux étaient des structures statiques ayant une taille prédéfinie. Vous devez utiliser une liste de tableaux, un vecteur ou toute autre structure dynamique.
vous pouvez créer un arraylist et utiliser Collection.addAll() pour convertir le tableau de chaînes en arraylist
Si vous voulez vraiment redimensionner un tableau, vous pouvez faire quelque chose comme ceci:
String[] arr = {"a", "b", "c"};
System.out.println(Arrays.toString(arr));
// Output is: [a, b, c]
arr = Arrays.copyOf(arr, 10); // new size will be 10 elements
arr[3] = "d";
arr[4] = "e";
arr[5] = "f";
System.out.println(Arrays.toString(arr));
// Output is: [a, b, c, d, e, f, null, null, null, null]
Vous pouvez simplement faire ceci:
System.arraycopy(initialArray, 0, newArray, 0, initialArray.length);
La taille du tableau ne peut pas être modifiée. Si vous devez utiliser un tableau, vous pouvez utiliser System.arraycopy (src, srcpos, dest, destpos, length);