Я тестировал большинство предлагаемых решений с помощью perfplot (мой собственный проект, по существу, обертка вокруг timeit
) и нашел
list(itertools.chain.from_iterable(a))
самым быстрым решением (если более 10 списков объединены).
Код для воспроизведения графика:
import functools
import itertools
import numpy
import operator
import perfplot
def forfor(a):
return [item for sublist in a for item in sublist]
def sum_brackets(a):
return sum(a, [])
def functools_reduce(a):
return functools.reduce(operator.concat, a)
def itertools_chain(a):
return list(itertools.chain.from_iterable(a))
def numpy_flat(a):
return list(numpy.array(a).flat)
def numpy_concatenate(a):
return list(numpy.concatenate(a))
perfplot.show(
setup=lambda n: [list(range(10))] * n,
kernels=[
forfor, sum_brackets, functools_reduce, itertools_chain, numpy_flat,
numpy_concatenate
],
n_range=[2**k for k in range(16)],
logx=True,
logy=True,
xlabel='num lists'
)
Другая альтернатива System.arraycopy
:
String[] stringArray = Arrays.copyOf(objectArray, objectArray.length, String[].class);
Object arr3[]=list1.toArray();
String common[]=new String[arr3.length];
for (int i=0;i<arr3.length;i++)
{
common[i]=(String)arr3[i];
}
Для вашей идеи на самом деле вы приближаетесь к успеху, но если вы делаете это, все должно быть хорошо:
for (int i=0;i<String_Array.length;i++) String_Array[i]=(String)Object_Array[i];
Кстати, использование утилиты Arrays довольно неплохо и делает код элегантным.
Я вижу, что некоторые решения были предоставлены, но не какие-либо причины, поэтому я объясню это подробно, поскольку считаю, что важно знать, что вы делаете неправильно, чтобы просто получить «что-то», которое работает с данными ответами.
Во-первых, давайте посмотрим, что должен сказать Oracle
* <p>The returned array will be "safe" in that no references to it are
* maintained by this list. (In other words, this method must
* allocate a new array even if this list is backed by an array).
* The caller is thus free to modify the returned array.
. Это может показаться неважным, но, как вы увидите, это ... Так что же может произойти следующая строка? Все объекты в списке - String, но они не преобразуют их, почему?
List<String> tList = new ArrayList<String>();
tList.add("4");
tList.add("5");
String tArray[] = (String[]) tList.toArray();
Возможно, многие из вас подумают, что этот код делает то же самое, но это не так.
Object tSObjectArray[] = new String[2];
String tStringArray[] = (String[]) tSObjectArray;
Когда на самом деле письменный код делает что-то подобное. Джавадок говорит это! Он установит новый массив, что это будет из объектов !!!
Object tSObjectArray[] = new Object[2];
String tStringArray[] = (String[]) tSObjectArray;
Так tList.toArray создает объекты, а не строки ...
Следовательно, естественное решение, которое не упоминалось в этом потоке, но это то, что Oracle рекомендует, это следующее
String tArray[] = tList.toArray(new String[0]);
Надеюсь, что это достаточно ясно.
Если вы хотите получить строковое представление объектов в своем массиве, то да, другого способа сделать это нет.
Если вы знаете, что ваш массив объектов содержит только строки, вы также можете do (instread to call toString ()):
for (int i=0;i<String_Array.length;i++) String_Array[i]= (String) Object_Array[i];
Единственный случай, когда вы могли бы использовать приведение в String [] объекта ObjectArray, было бы, если бы массив, на который он ссылается, фактически был бы определен как String [ ], например это будет работать:
Object[] o = new String[10];
String[] s = (String[]) o;
Это хорошо, но не работает, как заметили mmyers из-за квадратных скобок:
Arrays.toString(objectArray).split(",")
Это одно уродливое, но работает:
Arrays.toString(objectArray).replaceFirst("^\\[", "").replaceFirst("\\]$", "").split(",")
Если вы используете этот код, вы должны быть уверены, что строки, возвращаемые объектами toString (), не содержат запятых.
Вы можете использовать тип-конвертер . Чтобы преобразовать массив любых типов в массив строк, вы можете зарегистрировать свой собственный конвертер:
TypeConverter.registerConverter(Object[].class, String[].class, new Converter<Object[], String[]>() {
@Override
public String[] convert(Object[] source) {
String[] strings = new String[source.length];
for(int i = 0; i < source.length ; i++) {
strings[i] = source[i].toString();
}
return strings;
}
});
и использовать его
Object[] objects = new Object[] {1, 23.43, true, "text", 'c'};
String[] strings = TypeConverter.convert(objects, String[].class);
Легко менять без какой-либо головной боли Преобразование массива объектов в строковый массив Object drivex [] = {1,2};
for(int i=0; i<drive.length ; i++)
{
Str[i]= drivex[i].toString();
System.out.println(Str[i]);
}
Рамка коллекций google предлагает цитату хорошего метода преобразования, поэтому вы можете преобразовать объекты в строки. Единственный недостаток заключается в том, что он должен быть от Iterable до Iterable, но так я бы это сделал:
Iterable<Object> objects = ....... //Your chosen iterable here
Iterable<String> strings = com.google.common.collect.Iterables.transform(objects, new Function<Object, String>(){
String apply(Object from){
return from.toString();
}
});
Это уберет вас от использования массивов, но я думаю, что это было бы моим предпочтительным способом ,
В Java 8:
String[] strings = Arrays.stream(objects).toArray(String[]::new);
Для преобразования массива других типов:
String[] strings = Arrays.stream(obj).map(Object::toString).
toArray(String[]::new);
System.arraycopy, вероятно, самый эффективный способ, но для эстетики я бы предпочел:
Arrays.asList(Object_Array).toArray(new String[Object_Array.length]);