De liste de tableaux de Tableau

Je veux savoir si il est sûr/conseillé de convertir de liste de tableaux à la Matrice?
J'ai un fichier texte dont chaque ligne d'une chaîne de caractères:

Je veux les lire dans le tableau de la liste, puis-je le convertir en Tableau. Est-il conseillé/juridique pour le faire?

grâce

Vous pouvez, mais vous n'avez pas donné assez d'information pour vous dire si c'est une bonne idée ou pas.
ArrayLists sont beaux. La seule raison que je vois pour la conversion d'un Tableau est si vous avez besoin d'appeler une méthode qui exige.

InformationsquelleAutor Eddy Freeman | 2011-11-01

arraylist java

208

Oui il est sûr de convertir un ArrayList à Array. Si c'est une bonne idée dépend de l'utilisation prévue. Avez-vous besoin pour les opérations qui ArrayList offre? Si oui, garder un ArrayList. D'autre convertir de suite!!!
```
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);
```
sorties
```
bar.length = 5
```
- Que faire si ArrayList est vide?
- Alors qu'il est vide.
- The method toArray(T[]) in the type ArrayList<Character> is not applicable for the arguments (char[])
InformationsquelleAutor ObscureRobot
75

C'est le meilleur moyen (à mon humble avis).
```
List<String> myArrayList = new ArrayList<String>();
//.....
String[] myArray = myArrayList.toArray(new String[myArrayList.size()]);
```
Ce code fonctionne aussi:
```
String[] myArray = myArrayList.toArray(new String[0]);
```
Mais moins efficace: le tableau de chaîne est créé deux fois: la première fois, zéro-longueur du tableau est créé, puis le réel la taille du tableau est créé, rempli et retourné. Donc, si depuis vous connaissez la taille nécessaire (à partir de list.size()), vous devez créer une matrice qui est assez grand pour mettre tous les éléments. Dans ce cas, il n'est pas ré-alloué.
- bonne explication de la différence entre new String[0] et new String[size]
- new String[0] est en fait plus efficace. shipilev.net/blog/2016/arrays-wisdom-ancients
InformationsquelleAutor AlexR
6
```
ArrayList<String> myArrayList = new ArrayList<String>();
...
String[] myArray = myArrayList.toArray(new String[0]);
```
Si c'est une "bonne idée" serait vraiment dépend de votre cas d'utilisation.
- merci, juste curieux de savoir: je n'ai pas besoin de déclarer la taille du tableau?
- La documentation javadoc sont à votre ami. Si le tableau transmis est trop petit, un nouveau tableau est retourné. L'autre version de la méthode qui ne prend aucun argument renvoie un tableau de Object
InformationsquelleAutor Brian Roach
4

en supposant que v est une liste de tableaux:
```
String[] x = (String[]) v.toArray(new String[0]);
```
InformationsquelleAutor Erhan Bagdemir
2

Il y a deux styles de convertir une collection dans un tableau: soit à l'aide d'un pré-tableau de taille (comme c.toArray(new String[c.size()])) ou à l'aide d'un tableau vide (comme c.toArray(new String[0])).
Dans les anciennes versions de Java à l'aide de pré-tableau de taille a été recommandé, comme l'appel de réflexion qui est nécessaire pour créer un tableau de taille appropriée a été très lent. Cependant depuis la fin des mises à jour de OpenJDK 6 cet appel a été intrinsified, faisant de la performance du tableau vide version de la même chose et parfois même mieux, par rapport à la pré-version de taille moyenne. Aussi en passant pré-tableau de taille est dangereux pour un simultanées ou synchronisé de collecte de données, la race est possible entre la taille et toArray appel qui peut conduire à une les valeurs null à la fin du tableau, si la collection a été simultanément diminué au cours de l'opération.
Vous pouvez suivre le style uniforme: soit à l'aide d'un tableau vide (ce qui est recommandé dans moderne Java) ou à l'aide d'un pré-tableau de taille (qui pourrait être plus rapide dans les anciennes versions de Java ou de la non-HotSpot basé Jvm).

InformationsquelleAutor Alexander Savin
1
```
ArrayList<String> a = new ArrayList<String>();
a.add( "test" );
@SuppressWarnings( "unused")
Object[] array = a.toArray();
```
Cela dépend de ce que vous voulez faire si vous avez besoin de manipuler le tableau plus tard, il en coûterait plus d'effort que de le garder à la chaîne dans la liste de tableaux. Vous avez également accès aléatoire avec une liste de tableaux par list.get( index );

InformationsquelleAutor stacker
0

L'interface de Collecte comprend la méthode toArray() pour convertir une nouvelle collection dans un tableau. Il existe deux formes de cette méthode. Le pas d'argument version sera de retour les éléments de la collection dans un tableau d'Objets: public Object[ ] toArray(). Le tableau retourné ne peut pas lancer de tout autre type de données. C'est la version la plus simple. La deuxième version vous oblige à passer dans le type de données de la matrice que vous désirez retourner: public Object [ ] toArray(Objet de 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);  
           }  
      }  
```
de référence, reportez-vous à ce lien http://techno-terminal.blogspot.in/2015/11/how-to-obtain-array-from-arraylist.html

InformationsquelleAutor satish

Une approche possible serait d'ajouter le Second pour la Boucle lorsque l'impression est effectuée à l'intérieur de la première boucle. Comme ceci:

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]);
       }
   }    

}

InformationsquelleAutor Vipin Menon

String content = new String(Files.readAllBytes(Paths.get("C://temp//temp.txt")),
    StandardCharsets.UTF_8);

List<String> wordsList = Arrays.asList(content.split(System.getProperty("line.separator")));
Stream<String> wordsStream = Stream.of(content.split(System.getProperty("line.separator"))); 

//The resulting arrays
String[] wordsArray0 = wordsList.stream().toArray(String[]::new);
String[] wordsArray1 = wordsStream.toArray(String[]::new);

InformationsquelleAutor Aleksey Bykov

Vous devez vous connecter pour publier un commentaire.