JavaRush /Java блог /Random /Кофе-брейк #213. Как сортировать примитивные массивы в Ja...

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

Статья из группы Random

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

Источник: Asynq В этом руководстве рассмотрены три варианта сортировки примитивных массивов в Java. Кофе-брейк #213. Как сортировать примитивные массивы в Java. Прекратите использовать исключения в Java - 1Предположим, у нас есть массив 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. Кофе-брейк #213. Как сортировать примитивные массивы в Java. Прекратите использовать исключения в Java - 2Исключения (Exceptions) — это мощная функция Java, которая позволяет разработчикам структурированным и изящным образом обрабатывать ошибки и неожиданное поведение. Однако бывают случаи, когда исключения используются не по назначению, что приводит к раздутому и трудночитаемому коду.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

В заключение стоит сказать, что исключения — это эффективный инструмент для работы в Java, но им следует пользоваться экономно и осторожно. При правильном использовании исключения могут сделать ваш код более надежным и простым в обслуживании. Однако при неправильном использовании они могут привести к раздутому и трудночитаемому коду, а также к проблемам с безопасностью. Поэтому важно рассматривать альтернативы и использовать исключения только тогда, когда они необходимы.
Комментарии (5)
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
Денис Уровень 37
30 марта 2023
Касательно части об исключениях, правильнее было бы ее озаглавить "научитесь пользоваться механизмом исключений". Естественно, что любая технология используемая не по назначению будет работать плохо. Ну и перевод можно было бы улучшить :) Когда вы используете исключения для управления потоком вашего кода, может стать трудно понять поведение вашей программы. Обработка исключений усложняет понимание кода, становится труднее предсказать его поведение при возникновении исключений. When you use exceptions to control the flow of your code, it can become difficult to reason about the behavior of your program. Я бы перевел скорее как: "Использование исключений в качестве логических структур вашего кода усложняет его понимание." Как мне кажется, речь здесь идёт о чем-то вроде

        try {
            doSomething();
        } catch (Exception ex1) {
            try {
                doSomethingElse();
            } catch (Exception ex2) {
                // and so on
            }
        }
Касательно логирования, одно не исключает другого. Перехватив исключение есть смысл подумать о его логировании. Касательно ассертов, очень странно сравнивать их с исключениями. Они служат разным целям. Что любопытно, автор статьи не предложил использовать валидацию, для минимизации исключений. Очевидно, что плохие данные могут привести к неожиданным последствиям. Вместо того чтобы хендлить исключения, можно заранее убедиться, что данные подлежать обработке и только потом пускать их в работу. Это позволит избежать, например, NullPointerException.