current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
Stack Overflow is a community of 4.7 million programmers, just like you, helping each other.

Join them; it only takes a minute:

Sign up
Join the Stack Overflow community to:
  1. Ask programming questions
  2. Answer and help your peers
  3. Get recognized for your expertise
up vote 291 down vote favorite
64

How can I convert a List to an Array in Java?

Check the code below:

ArrayList<Tienda> tiendas;
List<Tienda> tiendasList; 
tiendas = new ArrayList<Tienda>();

Resources res = this.getBaseContext().getResources();
XMLParser saxparser =  new XMLParser(marca,res);

tiendasList = saxparser.parse(marca,res);
tiendas = tiendasList.toArray();

this.adaptador = new adaptadorMarca(this, R.layout.filamarca, tiendas);
setListAdapter(this.adaptador);

I need to populate the array tiendas with the values of tiendasList.

share|improve this question
15  
ArrayList isn't an array. Tienda[] would be an array. – Thomas Mar 5 '12 at 19:41

11 Answers 11

up vote 703 down vote accepted

Either:

Foo[] array = list.toArray(new Foo[list.size()]);

or:

Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array

Note that this works only for arrays of reference types. For arrays of primitive types, use the traditional way:

List<Integer> list = ...;
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) array[i] = list.get(i);
share|improve this answer
10  
for the first form I prefer list.toArray(new Foo[0]) as that makes it clear that the parameter is passed for the type information only and the size is irrelevant. – Marcus Junius Brutus Jul 10 '13 at 19:41
17  
@MarcusJuniusBrutus No, you are wrong. if you are using new Foo[0] then you are creating an extra useless array. Check the source code to verify. – Eng.Fouad Jul 10 '13 at 19:46
18  
Why it isn't just Foo[] array = list.toArray(); is beyond me. – Diederik Dec 4 '13 at 9:46
10  
@Diederik Because list.toArray() returns Object[] not Foo[]. – Powerlord Dec 5 '13 at 19:33
14  
@Diederik It's an unfortunately side effect of Java's Generics collections sharing classes with its non-Generic collections. Collection's .toArray() was defined way back in Java 1.0 or 1.1 as returning Object[] and it's far too late to change that now. Kinda makes me wish Java used different collections for generics like .NET did to avoid this insanity. – Powerlord Dec 5 '13 at 20:27
up vote 86 down vote

An alternative in Java 8:

String[] strings = list.stream().toArray(String[]::new);
share|improve this answer
13  
+1 Stream API is cool. – Eng.Fouad Apr 22 '14 at 21:37
1  
But is using Stream better in this particular case? – Basil Bourque Mar 7 '15 at 8:52
1  
This question is tagged for android, maybe you like to write your answer for the pure java question in stackoverflow.com/questions/4042434/… – PhoneixS May 18 '15 at 10:56
    
@PhoneixS with gradle-retrolambda it's possible to use java 8 functionality now. – Eddie B Sep 18 '15 at 13:11
up vote 17 down vote

I think this is the simplest way:

Foo[] array = list.toArray(new Foo[0]);
share|improve this answer
4  
Maybe set the correct size of the array, as you obviously know it – Oskar Kjellin Jul 3 '13 at 11:25
4  
^ No need to set the size of the array if this is the intended style. Documentation for toArray(T[] a): If the list fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this list. – Su Zhang Feb 13 '14 at 3:09
2  
@SuZhang If the list fits in the specified array. For sure the list does not fit into the passed array new Foo[0] (unless the list itself is empty), and a new array will be created for holding the list items. You are just passing the type of the array (while the object itself is useless). – Eng.Fouad Mar 11 '14 at 11:23
1  
@Eng.Fouad I should have made it clear that I was replying Oskar Kjellin :P – Su Zhang Mar 11 '14 at 17:56
1  
When passing in an array if too small size, the toArray() method has to construct a new array of the right size using reflexion. This has significantly worse performance than passing in an array of at least the size of the collection itself. Source: Intellij's inspection: git.jetbrains.org/?p=idea/community.git;a=blob;f=plugins/… – unify Apr 29 '14 at 20:25
up vote 1 down vote

I came across this code snippet that solves it.

//Creating a sample ArrayList 
List<Long> list = new ArrayList<Long>();

//Adding some long type values
list.add(100l);
list.add(200l);
list.add(300l);

//Converting the ArrayList to a Long
Long[] array = (Long[]) list.toArray(new Long[list.size()]);

//Printing the results
System.out.println(array[0] + " " + array[1] + " " + array[2]);

The conversion works as follows:

  1. It creates a new Long array, with the size of the original list
  2. It converts the original ArrayList to an array using the newly created one
  3. It casts that array into a Long array (Long[]), which I appropriately named 'array'
share|improve this answer
    
Posting someone else's code that works without any code comments or explanation is not a very compelling answer (but no -1 since it's technically correct). – Stuart Rossiter Jan 22 '15 at 16:37
    
Your comment however causes others to downvote my answer anyway. – Armed10 Jan 23 '15 at 10:07
    
While technically correct, this solution is redundant; you need either the (Long[]) cast, or the new Long[list.size()] argument to toArray, but not both! – jpaugh Dec 7 '15 at 22:11
up vote 0 down vote

This (Ondrej's answer):

Foo[] array = list.toArray(new Foo[0]);

Is the most common idiom I see. Those who are suggesting that you use the actual list size instead of "0" are misunderstanding what's happening here. The toArray call does not care about the size or contents of the given array - it only needs its type. It would have been better if it took an actual Type in which case "Foo.class" would have been a lot clearer. Yes, this idiom generates a dummy object, but including the list size just means that you generate a larger dummy object. Again, the object is not used in any way; it's only the type that's needed.

share|improve this answer
15  
You need to check the source code. If you use new Foo[0] then the array new Foo[0] will be ignored and a new array of a proper size will be created. If you use new Foo[list.size()] then the array new Foo[list.size()] will be filled and no other array will be created. – Eng.Fouad Sep 29 '13 at 0:53
up vote 0 down vote

For ArrayList the following works:

ArrayList<Foo> list = new ArrayList<Foo>();

//... add values

Foo[] resultArray = new Foo[list.size()];
resultArray = list.toArray(resultArray);
share|improve this answer
up vote 0 down vote

Example taken from this page: http://www.java-examples.com/copy-all-elements-java-arraylist-object-array-example

import java.util.ArrayList;

public class CopyElementsOfArrayListToArrayExample {

  public static void main(String[] args) {
    //create an ArrayList object
    ArrayList arrayList = new ArrayList();

    //Add elements to ArrayList
    arrayList.add("1");
    arrayList.add("2");
    arrayList.add("3");
    arrayList.add("4");
    arrayList.add("5");

    /*
      To copy all elements of java ArrayList object into array use
      Object[] toArray() method.
    */

    Object[] objArray = arrayList.toArray();

    //display contents of Object array
    System.out.println("ArrayList elements are copied into an Array.
                                                  Now Array Contains..");
    for(int index=0; index < objArray.length ; index++)
      System.out.println(objArray[index]);
  }
}

/*
Output would be
ArrayList elements are copied into an Array. Now Array Contains..
1
2
3
4
5
share|improve this answer
2  
Please don't just copy other people's work as your own, without attribution. java-examples.com/… – laalto Dec 2 '14 at 10:34
up vote 0 down vote

You can use toArray() api as follows,

ArrayList<String> stringList = new ArrayList<String>();
stringList.add("ListItem1");
stringList.add("ListItem2");
String[] stringArray = new String[stringList.size()];
stringArray = stringList.toArray(stringList);

Values from the array are,

for(String value : stringList)
{
    System.out.println(value);
}
share|improve this answer
up vote 0 down vote

This is works. Kind of.

public static Object[] toArray(List<?> a) {
    Object[] arr = new Object[a.size()];
    for (int i = 0; i < a.size(); i++)
        arr[i] = a.get(i);
    return arr;
}

Then the main method.

public static void main(String[] args) {
    List<String> list = new ArrayList<String>() {{
        add("hello");
        add("world");
    }};
    Object[] arr = toArray(list);
    System.out.println(arr[0]);
}
share|improve this answer
up vote -2 down vote 
tiendas = new ArrayList<Tienda>(tiendasList);

All collection implementations have an overloaded constructor that takes another collection (with the template <T> matching). The new instance is instantiated with the passed collection.

share|improve this answer
8  
This way you are just instantiating another List, not an array – Ruben Jan 7 '14 at 12:03
up vote -3 down vote

Try this:

List list = new ArrayList();
list.add("Apple");
list.add("Banana");

Object[] ol = list.toArray();
share|improve this answer
3  
Not useful, since one normally operates with generic types. – Rok Strniša Apr 5 '14 at 22:43

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.