Кофе-брейк #213. Как сортировать примитивные массивы в Java. Прекратите использовать исключения в Java

Как сортировать примитивные массивы в Java

Источник: Asynq В этом руководстве рассмотрены три варианта сортировки примитивных массивов в Java. Предположим, у нас есть массив int[] и нам нужно отсортировать этот массив по возрастанию и убыванию.

Входной массив

int[] arr = { 7,8,9,4,2,5};

Вариант 1

В первом случае мы будем использовать Arrays.sort(). Этот метод требует передачи массива объектов, и поскольку нам предоставлен примитивный массив, то придется выполнить упаковку (boxing). Для преобразования примитивного типа в объектный Stream API предоставляет boxed().

Integer[] arrBoxed = Arrays
                      .stream(arr)
                      .boxed()
                      .toArray(Integer[]::new);
Arrays.sort(arrBoxed);
System.out.println(Arrays.toString(arrBoxed));

Если тип возвращаемого значения должен быть int[], тогда мы можем сопоставить его с примитивным типом, используя Stream API.

int[] ints = Arrays.stream(arrBoxed).mapToInt(a -> a).toArray();

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

Arrays.sort(arrBoxed, Comparator.reverseOrder());

Arrays.sort(arrBoxed, (a,b) -> (b-a)); // lambda

Вариант 2

Здесь мы используем метод sorted(), предоставляемый Stream API.

int[] sortedArr = Arrays.stream(arr).sorted().toArray();
System.out.println(Arrays.toString(sortedArr));

Тип сортировки по умолчанию — по возрастанию. Если нам нужен тип сортировки по убыванию, тогда нам нужно немного изменить описанный выше подход. Stream API обеспечивает сортировку по типу объекта, который принимает компаратор, поэтому мы можем передать компаратор для определения порядка сортировки. Но есть нюанс — поскольку Stream API для примитива предоставляет метод sorted(), который не принимает никакого аргумента компаратора, мы не можем передать порядок. Таким образом, мы должны сначала упаковать примитивный тип в тип объекта, используя boxed().

int[] reverseSortedArr = Arrays.stream(arr)
       .boxed()
       .sorted(Collections.reverseOrder())
       .mapToInt(a ->a)
       .toArray();

Вариант 3

Этот вариант немного громоздок, так как требует слишком много преобразований и инициализаций. Для сортировки массива мы будем использовать Collections.sort(). Но функция Collections.sort() принимает в качестве аргумента список (list), поэтому сначала нам нужно преобразовать наш входной массив в список. Если мы используем Arrays.asList(), то мы получим List<int[]> из-за примитивной природы входного массива целых чисел.

List<int[]> ints1 = Arrays.asList(ints);

Здесь лучший способ — упаковать тип, а затем преобразовать его в список. При этом мы все еще инициализируем новый ArrayList со списком возврата из Stream API. Это связано с тем, что нам нужен изменяемый список для сортировки массива, а toList() предоставляет неизменяемый список, который мы не можем использовать для сортировки.

ArrayList<Integer> integers = new ArrayList<>(Arrays
                                               .stream(arr)
                                               .boxed()
                                               .toList()
                                              );

Получив список целых чисел ArrayList, мы можем использовать метод Collections.sort() для его сортировки.

ArrayList<Integer> integers = new ArrayList<>(Arrays.stream(arr).boxed().toList());
Collections.sort(integers);
// Collections.sort(integers, Comparator.reverseOrder()); sort in reverse
System.out.println(integers);

Заключение

В этой статье мы обсудили три различных варианта сортировки массива в Java. Мы также рассмотрели преобразование типа из примитива в объект и как это сделать с помощью Stream API Java 8.

Прекратите использовать исключения в Java

Источник: Medium Изучив эту публикацию, вы узнаете причины, из-за которых вам следует отказаться от использования исключений в Java. Исключения (Exceptions) — это мощная функция Java, которая позволяет разработчикам структурированным и изящным образом обрабатывать ошибки и неожиданное поведение. Однако бывают случаи, когда исключения используются не по назначению, что приводит к раздутому и трудночитаемому коду.

Исключения стоят дорого

Генерация исключения в Java — дорогостоящая операция. При возникновении исключения виртуальная машина Java (JVM) должна выполнить несколько действий, чтобы раскрутить стек вызовов, найти соответствующий блок catch и выполнить его. Этот процесс может быть медленным и способен существенно повлиять на производительность вашего кода.

Исключения усложняют понимание кода

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

Исключения могут скрывать ошибки

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

Исключения могут использоваться не по назначению

Разработчики часто используют исключения для потока управления, что не является их целью. Исключения следует использовать для обработки непредвиденных тельных ситуаций, а не для управления потоком кода. Неправильное использование исключений может затруднить чтение и понимание кода.

Исключения могут вызвать проблемы с безопасностью

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

Существуют альтернативы исключениям

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

1. Используйте коды ошибок или возвращаемые значения. Вместо создания исключения при возникновении ошибки вы можете вернуть код или значение ошибки, чтобы указать, что что-то пошло не так. Это может быть более эффективным и предсказуемым, чем использование исключений.

2. Используйте блок try-catch экономно. Блоки try-catch полезны для обработки исключений, но ими также можно злоупотреблять. Рассмотрите возможность их использования только в действительно исключительных ситуациях и обрабатывайте ожидаемые ошибки с помощью других методов.

3. Используйте утверждения (assertions). Утверждения — это мощный инструмент для обнаружения ошибок на ранних этапах процесса разработки. Они позволяют вам проверять предположения о вашем коде и преждевременно завершать работу, если что-то идет не так.

4. Используйте логирование. Логирование может стать эффективным способом отслеживания ошибок и неожиданного поведения в вашем коде. Регистрируя ошибки и предупреждения, вы можете упростить отладку кода и понять поведение своей программы.

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