какая из двух практик более эффективна в Java?

Question

У меня есть массив объектов, я знаю, что элементы имеют тип String, скажем, мне нужно обращаться к ним много раз.

• Практика 1: получить доступ к элементу по индексу массива и приводить его к строке каждый раз, когда мне это нужно.
• Практика 2. Создание локальных экземпляров String и доступ к каждому из элементов по одному разу.

Что будет работать быстрее? Если это на мобильном устройстве, где память ограничена, что было бы лучше всего? Спасибо.

Answer 1

Вы задаете не тот вопрос.Не оптимизируйте, пока не узнаете, что нужно оптимизировать.Вместо этого напишите самый понятный и простой для понимания код, который вы можете, а затем выполните рефакторинг, когда вы знаете, что есть проблема (и вы определили, в чем проблема).проще поддерживать массив и приводить его к String по мере необходимости.Если это окажется проблемой, я бы осуществил рефакторинг (возможно, создав массив String и скопировав в него объекты, один раз).

Answer 2

Если вы знаете, что все элементы String, то почему бы просто не создать массив String для начала?

Если они поступают откуда-то не под вашим контролем, проверьте, не является ли класспод вопросом поддерживает Generics или нет;вместо этого вы можете получить массив, возвращающий массив String.

Answer 3

Предполагая, что вы работаете на Java ME, по моему опыту, все сводится к

1. Сколько элементов массива доступно?
2. Каков размер исходного массива?

Помните, что создание другого массива путем приведения всех элементов дало бы отрицательный эффект, если бы только немногие из них были доступны. Кроме того, если вы пишете свой код таким образом, что один элемент массива должен быть приведен только один раз, то нет смысла приводить все сразу.

Answer 4

Если вы знаете, что типом является всегда строка, то почему бы не вызвать метод toString ().Это всегда даст вам фактическое значение ...

for (int x=0; x<whatever.length; ++x)
{
    System.out.println(whatever[x].toString());
}

Answer 5

Предполагая, что вы не можете сделать массив String [], а не Object [] ...

Если вы пройдете один раз, но затем будете использовать каждый элемент много раз, я напишу что-то вроде ...

for (int x=0; x<whatever.length; ++x)
{
  String whatever1=(String)whatever[x];

Затем используйте любую1 в теле цикла. Это означает, что вы выполняете поиск массива и приведение только один раз, а не повторно.

(То же самое применимо, если вы на самом деле не просматриваете цикл, а используете другие средства для поиска нужной записи, но по-прежнему используете каждую запись, как правило, только один раз.)

Если вам приходится многократно обрабатывать каждый элемент массива с использованием других элементов, может быть полезно скопировать Object [] в String [], например:

String[] sWhatever=new String[oWhatever.length];
for (int x=oWhatever.length-1; x>=0; --x)
  sWhatever[x]=(String)oWhatever[x];

(Можете ли вы написать «System.arraycopy (owh независимо, 0, sWh независимо, 0, oWhwhat.length)»? Я думаю, это будет работать, хотя я не пробовал.)

Будет ли копирование длиться дольше, чем приведение, будет зависеть от того, как часто вы будете разыгрывать каждый элемент. Я предполагаю, что это редко стоило бы, но это возможно.

Answer 6

Если вы знаете, что собираетесь получать доступ к одним и тем же данным много раз, было бы лучше избегать приведения и повторного приведения строк.

Answer 7

...

String s = (String)myarray[myelem_id];

не возвращает экземпляр локальной строки, но ссылается на существующий элемент - копия строки не создается.Поэтому вопрос сводится к следующему: лучше ли постоянно повторять (String)myarray[myelem_id] или писать его один раз, чтобы инициализировать локальную ссылку?

Второй легче читать - при условии, что ссылка имеет осмысленное имя, т.е. curItem.Я сомневаюсь, что в целом есть какие-то существенные различия в производительности, и я бы не стал измерять, если бы у меня не было действительно очень сильных проблем с производительностью (приведение не является операцией с нулевым временем, поскольку виртуальная машина вынуждена проверять тип, но это не медленно ).