ChatGPT解决这个技术问题 Extra ChatGPT

Converting 'ArrayList<String> to 'String[]' in Java

How might I convert an ArrayList<String> object to a String[] array in Java?

Have made this answer with an updated approach with JDK-11 introducing a new an equally performant API to toArray(T[]) and similar in syntax to Stream.toArray.

F
Floern
List<String> list = ..;
String[] array = list.toArray(new String[0]);

For example:

List<String> list = new ArrayList<String>();
//add some stuff
list.add("android");
list.add("apple");
String[] stringArray = list.toArray(new String[0]);

The toArray() method without passing any argument returns Object[]. So you have to pass an array as an argument, which will be filled with the data from the list, and returned. You can pass an empty array as well, but you can also pass an array with the desired size.

Important update: Originally the code above used new String[list.size()]. However, this blogpost reveals that due to JVM optimizations, using new String[0] is better now.


It shows this warning in logcat: Converting to string: TypedValue{t=0x12/d=0x0 a=3 r=0x7f050009}
@ThorbjørnRavnAndersen: the size of the array doesn't make any difference functionally but if you pass it in with the right size, you save the JVM the work of resizing it.
Turns out that providing a zero-length array, even creating it and throwing it away, is on average faster than allocating an array of the right size. For benchmarks and explanation see here: shipilev.net/blog/2016/arrays-wisdom-ancients
@StuartMarks It irks me that was only tested on Sun JVMs. There's no guarantee it will be faster on other systems such as ART (Android runtime) or IBM's JVM, which is used a lot on servers.
@lyuboslavkanev The problem is that having the generic type in Java isn't enough to actually create objects based on that type; not even an array (which is ridiculous, because that should work for any type). All that can be done with it, as far as I can see, is casting. In fact, to even create objects of the type, you need to have the actual Class object, which seems to be completely impossible to derive from the generic type. The reason for this, as I said, is that the whole construction is fake; it's all just stored as Object internally.
Z
ZhekaKozlov

An alternative in Java 8:

String[] strings = list.stream().toArray(String[]::new);

Java 11+:

String[] strings = list.toArray(String[]::new);

Or any benefits?
I would prefer that syntax, but IntelliJ displays a compiler error with that, complains "T[] is not a functional interface."
@GlenMazza you can only use toArray on a Stream object. This compilation error may occur if you reduce the stream using a Collectors and then try to apply toArray.
I don't get it. String[]::new is equivalent to () -> new String[]. But the given interface method expects an integer. Shouldn't it be (list.size()) -> new String[], so String[list.size()]::new ?
@JohnStrood String[]::new is equivalent to i -> new String[i]. See stackoverflow.com/questions/29447561/…
c
codecubed

You can use the toArray() method for List:

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

list.add("apple");
list.add("banana");

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

Or you can manually add the elements to an array:

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

list.add("apple");
list.add("banana");

String[] array = new String[list.size()];

for (int i = 0; i < list.size(); i++) {
    array[i] = list.get(i);
}

Hope this helps!


N
Naman

Starting from Java-11, one can use the API Collection.toArray(IntFunction<T[]> generator) to achieve the same as:

List<String> list = List.of("x","y","z");
String[] arrayBeforeJDK11 = list.toArray(new String[0]);
String[] arrayAfterJDK11 = list.toArray(String[]::new); // similar to Stream.toArray

S
SkyWalker
ArrayList<String> arrayList = new ArrayList<String>();
Object[] objectList = arrayList.toArray();
String[] stringArray =  Arrays.copyOf(objectList,objectList.length,String[].class);

Using copyOf, ArrayList to arrays might be done also.


Suggest camelcase so "objectList =..." and "stringArray". Also, it is Arrays.copyOf...capital O.
list.toArray() internally uses Arrays.copyOf()
M
Mike Shauneu

In Java 8:

String[] strings = list.parallelStream().toArray(String[]::new);

This is really already contained in this answer. Perhaps add it as an edit to that answer instead of as an entirely new one.
Why parallelStream() instead of simply stream()?
K
KayV

In Java 8, it can be done using

String[] arrayFromList = fromlist.stream().toArray(String[]::new);

Y
Yoory N.

If your application is already using Apache Commons lib, you can slightly modify the accepted answer to not create a new empty array each time:

List<String> list = ..;
String[] array = list.toArray(ArrayUtils.EMPTY_STRING_ARRAY);

// or if using static import
String[] array = list.toArray(EMPTY_STRING_ARRAY);

There are a few more preallocated empty arrays of different types in ArrayUtils.

Also we can trick JVM to create en empty array for us this way:

String[] array = list.toArray(ArrayUtils.toArray());

// or if using static import
String[] array = list.toArray(toArray());

But there's really no advantage this way, just a matter of taste, IMO.


A
Ahmed Ashour

You can use Iterator<String> to iterate the elements of the ArrayList<String>:

ArrayList<String> list = new ArrayList<>();
String[] array = new String[list.size()];
int i = 0;
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); i++) {
    array[i] = iterator.next();
}

Now you can retrive elements from String[] using any Loop.


I downvoted because: 1. no use of generics which force you into 2. using .toString() where no explicit cast would be needed, 3. you don't even increment i, and 4. the while would be better off replaced by a for. Suggested code: ArrayList<String> stringList = ... ; String[] stringArray = new String[stringList.size()]; int i = 0; for(Iterator<String> it = stringList.iterator(); it.hasNext(); i++) { stringArray[i] = it.next(); }
Okay, I got it now. Thanks.
Well, ideally, you should edit your code to include those comments (that is... if you think they're good for your answer!). I won't consider removing my downvote while the code remains unchanged.
I am new here, so I don't know yet how things work here. Although, appreciate your help mate.
This is much better! I've edited just a bit, but you've just experienced how it works: provide answer, improve them, get the laurels ;)
A
Ahmed Ashour

Generics solution to covert any List<Type> to String []:

public static  <T> String[] listToArray(List<T> list) {
    String [] array = new String[list.size()];
    for (int i = 0; i < array.length; i++)
        array[i] = list.get(i).toString();
    return array;
}

Note You must override toString() method.

class Car {
  private String name;
  public Car(String name) {
    this.name = name;
  }
  public String toString() {
    return name;
  }
}
final List<Car> carList = new ArrayList<Car>();
carList.add(new Car("BMW"))
carList.add(new Car("Mercedes"))
carList.add(new Car("Skoda"))
final String[] carArray = listToArray(carList);

If generics has a meaning, wouldn't it rather be "convert any List to Type[]"?
H
HZhang
List <String> list = ...
String[] array = new String[list.size()];
int i=0;
for(String s: list){
  array[i++] = s;
}

This works, but isn't super efficient, and duplicates functionality in the accepted answer with extra code.
R
Roberto Attias

in case some extra manipulation of the data is desired, for which the user wants a function, this approach is not perfect (as it requires passing the class of the element as second parameter), but works:

import java.util.ArrayList; import java.lang.reflect.Array;

public class Test {
  public static void main(String[] args) {
    ArrayList<Integer> al = new ArrayList<>();
    al.add(1);
    al.add(2);
    Integer[] arr = convert(al, Integer.class);
    for (int i=0; i<arr.length; i++)
      System.out.println(arr[i]);
  }

  public static <T> T[] convert(ArrayList<T> al, Class clazz) {
    return (T[]) al.toArray((T[])Array.newInstance(clazz, al.size()));
  }
}

S
Sled

In Java 11, we can use the Collection.toArray(generator) method. The following code will create a new array of strings:

List<String> list = List.of("one", "two", "three");
String[] array = list.toArray(String[]::new)

from java.base's java.util.Collection.toArray().


n
nick w.
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    String [] strArry= list.stream().toArray(size -> new String[size]);

Per comments, I have added a paragraph to explain how the conversion works. First, List is converted to a String stream. Then it uses Stream.toArray to convert the elements in the stream to an Array. In the last statement above "size -> new String[size]" is actually an IntFunction function that allocates a String array with the size of the String stream. The statement is identical to

IntFunction<String []> allocateFunc = size -> { 
return new String[size];
};   
String [] strArry= list.stream().toArray(allocateFunc);

What value does this answer add? It appears to just repeat other answers without explaining why it answers the question.
E
Ernestas Gruodis

You can convert List to String array by using this method:

 Object[] stringlist=list.toArray();

The complete example:

ArrayList<String> list=new ArrayList<>();
    list.add("Abc");
    list.add("xyz");

    Object[] stringlist=list.toArray();

    for(int i = 0; i < stringlist.length ; i++)
    {
          Log.wtf("list data:",(String)stringlist[i]);
    }

output type is wrong.
D
Denis Fedak
private String[] prepareDeliveryArray(List<DeliveryServiceModel> deliveryServices) {
    String[] delivery = new String[deliveryServices.size()];
    for (int i = 0; i < deliveryServices.size(); i++) {
        delivery[i] = deliveryServices.get(i).getName();
    }
    return delivery;
}