Comment utiliser une liste de tableaux en Java?

L'extrait de code suivant donne un exemple qui montre comment obtenir un élément à partir d'un List à un index spécifié, et aussi comment utiliser la boucle for-each avancée pour parcourir tous les éléments:

    import java.util.*;

    //...

    List<String> list = new ArrayList<String>();
    list.add("Hello!");
    list.add("How are you?");

    System.out.println(list.get(0)); // prints "Hello!"

    for (String s : list) {
        System.out.println(s);
    } // prints "Hello!", "How are you?"

Notez ce qui suit:

Les types
• génériques List<String> et ArrayList<String> sont utilisés à la place du type ArrayList brut.
• Les noms de variables commencent par des minuscules
• {[5] } est déclaré comme List<String>, c'est-à-dire le type d'interface au lieu du type d'implémentation ArrayList<String>.

Références

API:

• Je ne sais pas si c'est le cas.]}
• class ArrayList<E> implements List<E>
• interface List<E>
  • E get(int index)
    • Renvoie l'élément à la position spécifiée dans cette liste.

Ne pas utiliser les types bruts

• JLS 4.8 Types bruts

  L'utilisation de types bruts n'est autorisée qu'à titre de concession à la compatibilité du code hérité. L'utilisation de types raw dans le code écrit après l'introduction de genericity dans le langage de programmation Java est fortement déconseillée. Il est possible que les futures versions du langage de programmation Java interdisent l'utilisation de types raw.

• Efficace Java 2nd Edition: Article 23: Ne pas utiliser des types dans le nouveau code

  Si vous utilisez des types bruts, vous perdez toute la sécurité et l'expressivité avantages des génériques.

Préfère les interfaces aux classes d'implémentation dans les déclarations de type

• Effective Java 2nd Edition: Item 52: Se référer aux objets par leurs interfaces

  [...] vous devriez privilégier l'utilisation d'interfaces plutôt que de classes pour faire référence à des objets. S'il existe des types d'interface appropriés, les paramètres, les valeurs de retour, les variables et les champs doivent tous être déclarés à l'aide de l'interface types de.

Conventions de nommage

Variables: À l'exception des variables, toutes les constantes d'instance, de classe et de classe sont dans une casse mixte avec une première lettre minuscule .

Une Listest une collection ordonnée d'éléments. Vous pouvez les ajouter avec la méthode add et les récupérer avec la méthode get(int index). Vous pouvez également parcourir une Liste, supprimer des éléments, etc. Voici quelques exemples de base d'utilisation d'une liste:

List<String> names = new ArrayList<String>(3); // 3 because we expect the list 
    // to have 3 entries.  If we didn't know how many entries we expected, we
    // could leave this empty or use a LinkedList instead
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println(names.get(2)); // prints "Charlie"
System.out.println(names); // prints the whole list
for (String name: names) {
    System.out.println(name);  // prints the names in turn.
}

Vous pouvez obtenir vos chaînes par index (System.out.println(S.get(0));) ou les parcourir:

for (String s : S) {
  System.out.println(s);
}

Pour d'autres façons d'itérer à travers une liste (et leurs implications) voir traditionnel pour la boucle vs Itérateur en Java.

En plus:

• vous ne devez pas utiliser de noms de variables commençant par des lettres majuscules
• vous devez paramétrer votre liste de tableaux: ArrayList<String> list = new ArrayList<String>();
• vous devriez vous familiariser avec la vaste documentation de l'API de Java (aka Javadoc ), par exemple Java 5, Java 6

Cela devrait faire l'affaire:

String elem = (String)S.get(0);

Renverra le premier élément du tableau.

Ou

for(int i=0 ; i<S.size() ; i++){
     System.out.println(S.get(i));
}

Une solution à trois lignes, mais fonctionne assez bien:

int[] source_array = {0,1,2,3,4,5,6,7,8,9,10,11};
ArrayList<Integer> target_list = new ArrayList<Integer>();
for(int i = 0; i < source_array.length; i++){
    target_list.add(random_array[i]);
}

Si vous utilisez Java 1.5 ou au-delà, vous pouvez utiliser:

List<String> S = new ArrayList<String>();
s.add("My text");

for (String item : S) {
  System.out.println(item);
}

, Vous devriez lire collections cadre tutoriel tout d'abord.

Mais pour répondre à votre question, voici comment vous devriez le faire:

ArrayList<String> strings = new ArrayList<String>();
strings.add("String1");
strings.add("String2");

// To access a specific element:
System.out.println(strings.get(1));
// To loop through and print all of the elements:
for (String element : strings) {
    System.out.println(element);
}

Object get (int index) est utilisé pour renvoyer l'objet stocké index spécifié dans la collection d'appel.

Extrait de code:

import java.util.*;


class main
{
    public static void main(String [] args)
    {
        ArrayList<String> arr = new ArrayList<String>();
        arr.add("Hello!");
        arr.add("Ishe");
        arr.add("Watson?");

        System.out.printf("%s\n",arr.get(2)); 

        for (String s : arr) 
        {
            System.out.printf("%s\n",s);
        } 
    }
}

Java 8 a introduit l'implémentation par défaut de forEach() dans l'interface Itérable , vous pouvez facilement le faire par approche déclarative .

  List<String> values = Arrays.asList("Yasir","Shabbir","Choudhary");

  values.forEach( value -> System.out.println(value));

Voici le code de l'interface itérable

  default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

Référence

Tout d'abord, vous devrez définir le type de données que vous devez conserver dans votre liste. Comme vous avez mentionné que les données vont être String, la liste doit être de type String.

Ensuite, si vous voulez obtenir tous les éléments de la liste, vous devez simplement parcourir la liste en utilisant une simple boucle for ou a pour chaque boucle.

List <String> list = new ArrayList<>();
list.add("A");
list.add("B");

for(String s : list){
    System.out.println(s);
}

De plus, si vous souhaitez utiliser une ArrayList brute au lieu d'une liste générique, vous devrez réduire la valeur. Lors de l'utilisation de la liste de tableaux brute, tous les éléments sont stockés sous forme d'objet.

List list = new ArrayList();
list.add("A");
list.add("B");

for(Object obj : list){
    String s = (String) obj; //downcasting Object to String
    System.out.println(s);
}