Ява: Долой Старое, Новым

Question

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

Каковы некоторые типовые ситуации с кодом, особенно те, которые, как вы видите, люди реализуют по привычке, и которые вы реорганизуете, чтобы использовать последние версии Java?

Answer 1

Q1: Ну, наиболее очевидные ситуации в коллекциях дженериков / типов. Другой момент, который сразу же приходит на ум, - улучшенный цикл for, который, на мой взгляд, выглядит чище и проще для понимания.

Q2: В общем, я собирал JVM вместе с моим приложением для приложений, ориентированных на клиента. Это позволяет нам использовать новые языковые функции, не беспокоясь о несовместимости JVM.

Если бы я не связывал JRE, я бы, вероятно, придерживался 1.4 из соображений совместимости.

Answer 2

Простое изменение, начиная с версии 1.5, но имеет небольшое отличие - в API Swing, обращающемся к панели содержимого JFrame:

myframe.getContentPane().add(mycomponent);

становится

myframe.add(mycomponent);

И, конечно, введение Enums изменило поведение многих приложений, которые использовали константы в прошлом.

String.format () значительно улучшил манипулирование строками и троичный оператор if, что очень облегчает чтение кода.

Answer 3

Общие коллекции делают кодирование намного более устойчивым к ошибкам. OLD:

Vector stringVector = new Vector();
stringVector.add("hi");
stringVector.add(528); // oops!
stringVector.add(new Whatzit());  // Oh my, could spell trouble later on!

NEW:

ArrayList<String> stringList = new ArrayList<String>();
stringList.add("hello again");
stringList.add(new Whatzit()); // Won't compile!

Answer 4

Использование итератора:

List list = getTheList();
Iterator iter = list.iterator()
while (iter.hasNext()) {
  String s = (String) iter.next();
    // .. do something
}

Или иногда встречается альтернативная форма:

List list = getTheList();
for (Iterator iter = list.iterator(); iter.hasNext();) {
  String s = (String) iter.next();
  // .. do something
}

Теперь все заменено на:

List<String> list = getTheList();
for (String s : list) {
  // .. do something
}

Answer 5

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

import static Math.* ;

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

Answer 6

Преобразование числа в строку:

String s = n + "";

В этом случае я думаю, что всегда был лучший способ сделать это:

String s = String.valueOf(n);

Answer 7

копирование существующего массива в новый массив:

до Java 5 :

int[] src = new int[] {1, 2, 3, 4, 5};
int[] dest = new int[src.length];
System.arraycopy(src, 0, dest, 0, src.length);

Java 6 :

int[] src = new int[] {1, 2, 3, 4, 5};
int[] dest = Arrays.copyOf(src, src.length);

Раньше мне приходилось явно создавать новый массив, а затем копировать исходные элементы в новый массив (вызывая метод с большим количеством параметров). теперь синтаксис более чистый и новый массив возвращается из метода, мне не нужно его создавать. кстати, метод Arrays.copyOf имеет вариант с именем Arrays.copyOfRange , который копирует определенную область исходного массива (в значительной степени как System.arraycopy ).

Answer 8

Новая конструкция for -each для перебора массивов и коллекций - самая большая для меня.

В наши дни, когда я вижу циклический шаблон for, который перебирает массив один за другим с помощью индексной переменной, мне хочется кричать:

// AGGHHH!!!
int[] array = new int[] {0, 1, 2, 3, 4};
for (int i = 0; i < array.length; i++)
{
    // Do something...
}

Замена вышеупомянутого конструктом for, представленным в Java 5 :

// Nice and clean.    
int[] array = new int[] {0, 1, 2, 3, 4};
for (int n : array)
{
    // Do something...
}

Чисто, кратко и, что лучше всего, он дает значение коду, а не показывает , как что-то сделать.

Очевидно, что код имеет смысл перебирать коллекцию, а не старый цикл for, в котором говорится, как перебирать массив.

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

Answer 9

Относится к varargs ; служебный метод Arrays.asList () , который, начиная с Java 5, принимает параметры varargs, чрезвычайно полезен.

Я часто нахожу себя упрощающим что-то вроде

List<String> items = new ArrayList<String>();
items.add("one");
items.add("two");
items.add("three");
handleItems(items);

с помощью

handleItems(Arrays.asList("one", "two", "three"));

Answer 10

Аннотации

Интересно, что до сих пор никто не упоминал об этом, но многие фреймворки используют аннотации, например, Spring и Hibernate. В наши дни принято считать устаревшими XML-файлы конфигурации в пользу аннотации в коде (хотя это означает потерю гибкости при переходе от конфигурации к метакоду, но часто это правильный выбор). Лучшим примером является EJB 2 (и старше) по сравнению с EJB 3.0 и тем, как программируется EJB был упрощен благодаря аннотациям.

Мне также очень полезны аннотации в сочетании с некоторыми инструментами AOP, такими как AspectJ или Spring AOP. Такое сочетание может быть очень мощным.