Is there a better way of achieving this?
public static List<String> toList(String[] array) {
List<String> list = new ArrayList(array.length);
for(int i=0; i<array.length; i++)
list.add(array[i]);
return list;
}
NOTE: Arrays.asList(a) Returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.). I don't want that behavior. I assume that MY function above bypasses that (or am I wrong?)
So, here we have the alternative method:
public static List<String> toList(String[] array) {
List<String> list = new ArrayList(array.length);
list.addAll(Arrays.asList(array));
return list;
}
Just looking at it, I don't believe it's FASTER than the first method.
This question is related to
java
arrays
collections
What do you mean by better way:
more readable:
List<String> list = new ArrayList<String>(Arrays.asList(array));
less memory consumption, and maybe faster (but definitely not thread safe):
public static List<String> toList(String[] array) {
if (array==null) {
return new ArrayList(0);
} else {
int size = array.length;
List<String> list = new ArrayList(size);
for(int i = 0; i < size; i++) {
list.add(array[i]);
}
return list;
}
}
Btw: here is a bug in your first example:
array.length will raise a null pointer exception if array is null, so the check if (array!=null) must be done first.
Another way to do it:
Collections.addAll(collectionInstance,array);
Have you checked Arrays.asList(); see API
You can try something like this:
List<String> list = new ArrayList<String>(Arrays.asList(array));
public ArrayList(Collection c)
Constructs a list containing the elements of the specified collection, in the order they are returned by the collection's iterator. The ArrayList instance has an initial capacity of 110% the size of the specified collection.
Taken from here
You can use:
list.addAll(Arrays.asList(array));
What about :
List myList = new ArrayList();
String[] myStringArray = new String[] {"Java", "is", "Cool"};
Collections.addAll(myList, myStringArray);
Yes, there is. You can use the Arrays class from the java.util.* package. Then it's actually just one line of code.
List<String> list = Arrays.asList(array);
Arrays.asList(array)
Arrays uses new ArrayList(array). But this is not the java.util.ArrayList. It's very similar though. Note that this constructor takes the array and places it as the backing array of the list. So it is O(1).
In case you already have the list created, Collections.addAll(list, array), but that's less efficient.
Update: Thus your Collections.addAll(list, array) becomes a good option. A wrapper of it is guava's Lists.newArrayList(array).
Arrays.asList(array);
Example:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
See Arrays.asList class documentation.
Based on the reference of java.util.Collections.addAll(Collection<? super String> c, String... elements) its implementation is similar to your first method, it says
Adds all of the specified elements to the specified collection. Elements to be added may be specified individually or as an array. The behavior of this convenience method is identical to that of c.addAll(Arrays.asList(elements)), but this method is likely to run significantly faster under most implementations.
Its implementation in jdk is (jdk7)
public static <T> boolean addAll(Collection<? super T> c, T... elements) {
boolean result = false;
for (T element : elements)
result |= c.add(element);
return result;
}
So among your samples the better approach must be Collections.addAll(list, array);
Since Java 8, we can use Stream api which may perform better
Eg:-
String[] array = {"item1", "item2", "item3"};
Stream<String> stream = Stream.of(array);
//if the array is extremely large
stream = stream.parallel();
final List<String> list = stream.collect(Collectors.toList());
If the array is very large we can do it as a batch operation in parallel using parallel stream (stream = stream.parallel()) that will utilize all CPUs to finish the task quickly. If the array length is very small parallel stream will take more time than sequential stream.
Source: Stackoverflow.com