De Arraylist à Array

Je veux savoir s'il est sûr / conseillé de convertir ArrayList en Array? J'ai un fichier texte avec chaque ligne une chaîne:

1236
1233
4566
4568
....

Je veux les lire dans une liste de tableaux, puis je les convertis en tableau. Est-il conseillé / légal de faire cela?

Merci

Oui , il est sûr de convertir un ArrayListà unArray . Que ce soit une bonne idée dépend de votre utilisation prévue. Avez-vous besoin des opérations qui ArrayListfournissent? Si tel est le cas, conservez-le au format ArrayList. Sinon, convertissez-vous!

ArrayList<Integer> foo = new ArrayList<Integer>();
foo.add(1);
foo.add(1);
foo.add(2);
foo.add(3);
foo.add(5);
Integer[] bar = foo.toArray(new Integer[foo.size()]);
System.out.println("bar.length = " + bar.length);

les sorties

bar.length = 5

C'est la meilleure façon (à mon humble avis).

List<String> myArrayList = new ArrayList<String>();
//.....
String[] myArray = myArrayList.toArray(new String[myArrayList.size()]);

Ce code fonctionne également:

String[] myArray = myArrayList.toArray(new String[0]);

Mais c'est moins efficace: le tableau de chaînes est créé deux fois: la première fois que le tableau de longueur nulle est créé, le tableau de taille réelle est créé, rempli et renvoyé. Donc, si vous connaissez la taille nécessaire (à partir de list.size()), vous devez créer un tableau suffisamment grand pour contenir tous les éléments. Dans ce cas, il n'est pas réaffecté.

ArrayList<String> myArrayList = new ArrayList<String>();
...
String[] myArray = myArrayList.toArray(new String[0]);

Que ce soit une "bonne idée" dépendra vraiment de votre cas d'utilisation.

en supposant que v est une ArrayList:

String[] x = (String[]) v.toArray(new String[0]);

Il existe deux styles pour convertir une collection en tableau: soit en utilisant un tableau pré-dimensionné (comme c.toArray(new String[c.size()])), soit en utilisant un tableau vide (comme c.toArray(new String[0])). Dans les anciennes versions de Java, il était recommandé d'utiliser un tableau prédimensionné, car l'appel de réflexion nécessaire pour créer un tableau de taille appropriée était assez lent. Cependant, depuis les dernières mises à jour d' OpenJDK 6, cet appel était intrinsèque, rendant les performances de la version de tableau vide les mêmes et parfois même meilleures, par rapport à la version pré-dimensionnée. Le passage d'un tableau pré-dimensionné est également dangereux pour une collection simultanée ou synchronisée, car une course aux données est possible entre la taille et l'appel toArray, ce qui peut entraîner des valeurs nulles supplémentaires à la fin du tableau, si la collection a été réduite simultanément pendant l'opération. Vous pouvez suivre le style uniforme:soit en utilisant un tableau vide (ce qui est recommandé dans Java moderne) ou en utilisant un tableau pré-dimensionné (qui peut être plus rapide dans les anciennes versions de Java ou les JVM non basées sur HotSpot) .

Il s'agit de l'utilisation recommandée pour les nouveaux Java (> Java 6)

String[] myArray = myArrayList.toArray(new String[0]);

Dans les anciennes versions de Java, il était recommandé d'utiliser un tableau prédimensionné, car l'appel de réflexion nécessaire pour créer un tableau de taille appropriée était assez lent. Cependant, depuis les dernières mises à jour d'OpenJDK 6, cet appel était intrinsèque, rendant les performances de la version de tableau vide les mêmes et parfois même meilleures, par rapport à la version pré-dimensionnée. Le passage d'un tableau prédimensionné est également dangereux pour une collection simultanée ou synchronisée, car une course de données est possible entre la taille et l'appel toArray, ce qui peut entraîner des valeurs nulles supplémentaires à la fin du tableau, si la collection a été réduite simultanément pendant l'opération. Cette inspection permet de suivre le style uniforme: soit en utilisant un tableau vide (ce qui est recommandé dans Java moderne), soit en utilisant un tableau pré-dimensionné (qui pourrait être plus rapide dans les anciennes versions de Java ou les JVM non basées sur HotSpot).

L'interface Collection inclut la méthode toArray () pour convertir une nouvelle collection en tableau. Il existe deux formes de cette méthode. La version sans argument renverra les éléments de la collection dans un tableau Object: public Object [] toArray (). Le tableau renvoyé ne peut pas convertir en un autre type de données. Ceci est la version la plus simple. La deuxième version nécessite que vous passiez le type de données du tableau que vous souhaitez renvoyer: public Object [] toArray (Object type []).

 public static void main(String[] args) {  
           List<String> l=new ArrayList<String>();  
           l.add("A");  
           l.add("B");  
           l.add("C");  
           Object arr[]=l.toArray();  
           for(Object a:arr)  
           {  
                String str=(String)a;  
                System.out.println(str);  
           }  
      }  

pour référence, reportez-vous à ce lien http://techno-terminal.blogspot.in/2015/11/how-to-obtain-array-from-arraylist.html

Une approche serait d'ajouter la deuxième boucle for où l'impression est effectuée à l'intérieur de la première boucle for. Comme ça:

static String[] SENTENCE; 

public static void main(String []args) throws Exception{

   Scanner sentence = new Scanner(new File("assets/blah.txt"));
   ArrayList<String> sentenceList = new ArrayList<String>();

   while (sentence.hasNextLine())
   {
       sentenceList.add(sentence.nextLine());
   }

   sentence.close();

   String[] sentenceArray = sentenceList.toArray(new String[sentenceList.size()]);
  // System.out.println(sentenceArray.length);
   for (int r=0;r<sentenceArray.length;r++)
   {
       SENTENCE = sentenceArray[r].split("(?<=[.!?])\\s*"); //split sentences and store in array 

       for (int i=0;i<SENTENCE.length;i++)
       {
           System.out.println("Sentence " + (i+1) + ": " + SENTENCE[i]);
       }
   }    

}

ArrayList<String> a = new ArrayList<String>();
a.add( "test" );
@SuppressWarnings( "unused")
Object[] array = a.toArray();

Cela dépend de ce que vous voulez réaliser si vous devez manipuler le tableau plus tard, cela coûtera plus d'efforts que de conserver la chaîne dans ArrayList. Vous avez également un accès aléatoire avec une ArrayList parlist.get( index );