De Arraylist para Array

Eu quero saber se é seguro / aconselhável converter de ArrayList para Array? Eu tenho um arquivo de texto com cada linha uma string:

1236
1233
4566
4568
....

Eu quero lê-los na lista de array e, em seguida, convertê-lo em Array. É aconselhável / legal fazer isso?

obrigado

Sim , é seguro converter um ArrayListem umArray . Se é uma boa ideia depende do uso pretendido. Você precisa das operações que ArrayListfornece? Em caso afirmativo, mantenha um ArrayList. Senão, converta-se!

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

saídas

bar.length = 5

Esta é a melhor forma (IMHO).

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

Este código também funciona:

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

Mas é menos eficaz: a matriz de string é criada duas vezes: na primeira vez, a matriz de comprimento zero é criada, depois a matriz de tamanho real é criada, preenchida e retornada. Então, se você sabe o tamanho necessário (de list.size()), você deve criar um array que seja grande o suficiente para colocar todos os elementos. Nesse caso, ele não é realocado.

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

Se é uma "boa ideia" realmente depende do seu caso de uso.

presumindo que v é um ArrayList:

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

Existem dois estilos para converter uma coleção em uma matriz: usando uma matriz pré-dimensionada (como c.toArray(new String[c.size()])) ou usando uma matriz vazia (como c.toArray(new String[0])). Em versões anteriores do Java, o uso de um array pré-dimensionado era recomendado, pois a chamada de reflexão necessária para criar um array de tamanho adequado era bastante lenta. No entanto, desde as últimas atualizações do OpenJDK 6, essa chamada foi intrinsecada, tornando o desempenho da versão do array vazio o mesmo e às vezes até melhor, em comparação com a versão pré-dimensionada. Além disso, passar um array pré-dimensionado é perigoso para uma coleção simultânea ou sincronizada, pois uma corrida de dados é possível entre o tamanho e a chamada toArray, o que pode resultar em nulos extras no final do array, se a coleção for encolhida simultaneamente durante a operação. Você pode seguir o estilo do uniforme:usando um array vazio (o que é recomendado no Java moderno) ou usando um array pré-dimensionado (que pode ser mais rápido em versões mais antigas do Java ou JVMs não baseados em HotSpot) .

Este é o uso recomendado para o Java mais recente (> Java 6)

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

Em versões anteriores do Java, o uso de um array pré-dimensionado era recomendado, pois a chamada de reflexão necessária para criar um array de tamanho adequado era bastante lenta. No entanto, desde as últimas atualizações do OpenJDK 6, essa chamada foi intrinsecada, tornando o desempenho da versão do array vazio o mesmo e às vezes até melhor, em comparação com a versão pré-dimensionada. Além disso, passar um array pré-dimensionado é perigoso para uma coleção simultânea ou sincronizada, pois uma corrida de dados é possível entre o tamanho e a chamada toArray, o que pode resultar em nulos extras no final do array, se a coleção for encolhida simultaneamente durante a operação. Esta inspeção permite seguir o estilo uniforme: usando um array vazio (o que é recomendado no Java moderno) ou usando um array pré-dimensionado (que pode ser mais rápido em versões mais antigas de Java ou JVMs não baseados em HotSpot).

A interface Collection inclui o método toArray () para converter uma nova coleção em um array. Existem duas formas desse método. A versão sem argumento retornará os elementos da coleção em uma matriz Object: public Object [] toArray (). A matriz retornada não pode ser convertida em nenhum outro tipo de dados. Esta é a versão mais simples. A segunda versão requer que você passe o tipo de dados do array que deseja retornar: 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);  
           }  
      }  

para referência, consulte este link http://techno-terminal.blogspot.in/2015/11/how-to-obtain-array-from-arraylist.html

Uma abordagem seria adicionar o segundo for loop onde a impressão está sendo feita dentro do primeiro for loop. Como isso:

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

Depende do que você deseja alcançar. Se precisar manipular o array posteriormente, custaria mais esforço do que manter a string no ArrayList. Você também tem acesso aleatório com uma ArrayList porlist.get( index );