Von der Arrayliste zum Array

111

Ich möchte wissen, ob es sicher / ratsam ist, von ArrayList zu Array zu konvertieren. Ich habe eine Textdatei mit jeder Zeile eine Zeichenfolge:

1236
1233
4566
4568
....

Ich möchte sie in eine Array-Liste einlesen und sie dann in ein Array konvertieren. Ist es ratsam / legal, das zu tun?

Vielen Dank

Eddy Freeman
quelle
8
Sie können , aber Sie haben uns nicht annähernd genug Informationen gegeben, um Ihnen zu sagen, ob es eine gute Idee ist oder nicht.
Jon Skeet
6
ArrayLists sind in Ordnung. Der einzige Grund, den ich für die Konvertierung in ein Array sehen kann, ist, wenn Sie eine Methode aufrufen müssen, die dies erfordert.
Mike Jones

Antworten:

214

Ja, es ist sicher, ein ArrayListin ein umzuwandelnArray . Ob dies eine gute Idee ist, hängt von Ihrem Verwendungszweck ab. Benötigen Sie die Operationen, die ArrayListbereitstellt? Wenn ja, behalten Sie es ArrayList. Sonst konvertieren weg!

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

Ausgänge

bar.length = 5
ObscureRobot
quelle
Was ist, wenn ArrayList leer ist?
ThanosFisherman
48
Dann ist es leer.
IMustBeSomeone
1
The method toArray(T[]) in the type ArrayList<Character> is not applicable for the arguments (char[])
Aaron Franke
75

Dies ist der beste Weg (IMHO).

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

Dieser Code funktioniert auch:

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

Aber es ist weniger effektiv: Das String-Array wird zweimal erstellt: Wenn zum ersten Mal ein Array mit der Länge Null erstellt wird, wird das Array in realer Größe erstellt, gefüllt und zurückgegeben. Wenn Sie also die erforderliche Größe (von list.size()) kennen, sollten Sie ein Array erstellen, das groß genug ist, um alle Elemente zu platzieren. In diesem Fall wird es nicht neu zugewiesen.

AlexR
quelle
4
gute Erklärung für den Unterschied zwischen new String[0]undnew String[size]
Gamliela
4
new String[0]ist eigentlich effizienter. shipilev.net/blog/2016/arrays-wisdom-ancients
Radiodef
5
ArrayList<String> myArrayList = new ArrayList<String>();
...
String[] myArray = myArrayList.toArray(new String[0]);

Ob es sich um eine "gute Idee" handelt, hängt wirklich von Ihrem Anwendungsfall ab.

Brian Roach
quelle
danke, nur neugierig zu wissen: ich muss die Array-Größe nicht deklarieren?
Eddy Freeman
JavaDocs sind dein Freund. Wenn das übergebene Array zu klein ist, wird ein neues Array zurückgegeben. Die andere Version der Methode, die keine Object
Brian Roach
3

Angenommen, v ist eine ArrayList:

String[] x = (String[]) v.toArray(new String[0]);
Erhan Bagdemir
quelle
1

Es gibt zwei Stile, um eine Sammlung in ein Array zu konvertieren: entweder mit einem Array mit Vorgröße (wie c.toArray(new String[c.size()])) oder mit einem leeren Array (wie c.toArray(new String[0])). In älteren Java-Versionen wurde die Verwendung eines vorgefertigten Arrays empfohlen, da der Reflection-Aufruf, der zum Erstellen eines Arrays mit der richtigen Größe erforderlich ist, recht langsam war. Seit den späten Aktualisierungen von OpenJDK 6 war dieser Aufruf jedoch nicht mehr gültig, sodass die Leistung der leeren Array-Version im Vergleich zur vorgroßen Version gleich und manchmal sogar noch besser war. Das Übergeben eines Arrays mit vorgroßer Größe ist für eine gleichzeitige oder synchronisierte Sammlung gefährlich, da ein Datenrennen zwischen der Größe und dem toArray-Aufruf möglich ist, was zu zusätzlichen Nullen am Ende des Arrays führen kann, wenn die Sammlung während des Vorgangs gleichzeitig verkleinert wurde. Sie können dem einheitlichen Stil folgen:Verwenden Sie entweder ein leeres Array (was in modernem Java empfohlen wird) oder ein Array mit einer Vorgröße (das in älteren Java-Versionen oder nicht auf HotSpot basierenden JVMs möglicherweise schneller ist) .

Alexander Savin
quelle
1

Dies ist die empfohlene Verwendung für neueres Java (> Java 6).

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

In älteren Java-Versionen wurde die Verwendung eines Arrays mit vorgefertigter Größe empfohlen, da der Reflection-Aufruf, der zum Erstellen eines Arrays mit der richtigen Größe erforderlich ist, recht langsam war. Seit den späten Updates von OpenJDK 6 war dieser Aufruf jedoch nicht mehr gültig, sodass die Leistung der leeren Array-Version im Vergleich zur vorgroßen Version gleich und manchmal sogar noch besser war. Das Übergeben eines Arrays mit vorgroßer Größe ist für eine gleichzeitige oder synchronisierte Sammlung gefährlich, da ein Datenrennen zwischen der Größe und dem toArray-Aufruf möglich ist, was zu zusätzlichen Nullen am Ende des Arrays führen kann, wenn die Sammlung während des Vorgangs gleichzeitig verkleinert wurde. Diese Überprüfung ermöglicht es, dem einheitlichen Stil zu folgen: entweder mit einem leeren Array (was in modernem Java empfohlen wird) oder mit einem Array mit Vorgröße (das in älteren Java-Versionen oder nicht auf HotSpot basierenden JVMs möglicherweise schneller ist).

Majurageerthan
quelle
0

Die Collection-Schnittstelle enthält die toArray () -Methode zum Konvertieren einer neuen Collection in ein Array. Es gibt zwei Formen dieser Methode. Die Version ohne Argument gibt die Elemente der Auflistung in einem Object-Array zurück: public Object [] toArray (). Das zurückgegebene Array kann nicht in einen anderen Datentyp umgewandelt werden. Dies ist die einfachste Version. In der zweiten Version müssen Sie den Datentyp des Arrays übergeben, das Sie zurückgeben möchten: 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);  
           }  
      }  

Als Referenz siehe diesen Link http://techno-terminal.blogspot.in/2015/11/how-to-obtain-array-from-arraylist.html

satish
quelle
0

Ein Ansatz wäre, die zweite for-Schleife hinzuzufügen, bei der der Druck innerhalb der ersten for-Schleife erfolgt. So was:

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

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

Es hängt davon ab, was Sie erreichen möchten, wenn Sie das Array später bearbeiten müssen. Dies würde mehr Aufwand kosten, als die Zeichenfolge in der ArrayList zu belassen. Sie haben auch wahlfreien Zugriff mit einer ArrayList vonlist.get( index );

Stapler
quelle