Понимание методов Autoboxing, Auto-Unboxing, расширения и переменных аргументов в Java
Источник:
Medium
В этой статье рассматриваются четыре ключевые концепции, входящие в пакет java.lang: методы Autoboxing, Auto-Unboxing, расширения и методы переменных аргументов в Java.
Пакет
java.lang в Java служит основой для множества фундаментальных функций, включая примитивные типы данных, классы-оболочки (wrapper classes) и основные функции языка (Java Core). С некоторыми из них мы сейчас познакомимся поближе.
Autoboxing
Autoboxing (Автоупаковка) — это автоматическое преобразование примитивного типа в соответствующий класс-оболочку. Взгляните на следующий фрагмент кода:
int primitive = 10;
Integer wrapper = primitive; // Autoboxing
Здесь
int со значением 10 автоматически помещается в объект
Integer.
Auto-Unboxing
Auto-unboxing (Автораспаковка) — это автоматическое преобразование объекта класса-оболочки в соответствующий примитивный тип. Например:
Integer wrapper = 20;
int primitive = wrapper; // Auto-unboxing
В этом примере кода объект
Integer, содержащий значение 20, автоматически распаковывается в файл
int.
Автоупаковка и автоматическая распаковка делают код более кратким и читаемым, устраняя необходимость явных преобразований между примитивными типами и соответствующими им классами-оболочками.
Методы расширения
Расширение (Widening) относится к процессу преобразования значения из меньшего типа данных в больший тип данных без потери информации. В Java этот процесс неявный и известен как расширяющее преобразование. Примеры расширения:
int intValue = 10;
long longValue = intValue; // Расширяем преобразование из int в long
float floatValue = 3.14f;
double doubleValue = floatValue; // Расширяем преобразование из float в double
Здесь в обоих случаях значения автоматически расширяются до большего типа данных (
long и
double соответственно).
Расширяющие преобразования выполняются в следующих ситуациях:
- Если константа целочисленного литерала (Integer literal) присваивается переменной типа long.
- Если константа литерала с плавающей запятой (literal floating-point) присваивается переменной типа float или double.
- Когда меньший целочисленный тип (например, byte, short, char или int) присваивается большему целочисленному типу (например, от short к int, от int к long и т. д.).
Varargs Methods (Методы переменных аргументов)
Varargs, сокращение от аргументов переменной длины (variable-length arguments), позволяет методам принимать переменное количество аргументов указанного типа. Эта функция упрощает создание методов, работающих с переменным количеством входных данных.
Синтаксис
Синтаксис объявления параметра с переменным числом аргументов заключается в использовании многоточия (
...) после типа параметра.
public void exampleMethod(String... strings) {
// Тело метода
}
Пример использования:
public void printValues(String... values) {
for (String value : values) {
System.out.println(value);
}
}
// Вызов метода
printValues("Hello", "World"); // Вывод: Hello World
printValues("Java", "is", "awesome"); // Вывод: Java is awesome
Методы Varargs могут принимать ноль или более аргументов указанного типа. Внутри аргументы обрабатываются как массив указанного типа.
Заключение
Методы Autoboxing, Auto-Unboxing, расширения и Varargs (переменных аргументов) — это функции, представленные в Java для упрощения обработки примитивных типов и параметризации методов. Они улучшают читаемость кода, уменьшают количество шаблонов и обеспечивают большую гибкость при вызове методов. Однако важно понимать их значение и модели использования, чтобы эффективно использовать их в программировании на Java.
Обработка дат в Java: сравниваем java.util.Date с LocalDateTime
Источник:
Medium
Это руководство поможет вам понять различия и преимущества классов java.util.Date от LocalDateTime. Также вы узнаете лучшие варианты их использования.
Раньше в Java-программировании работа с датами была серьезной проблемой, особенно с учетом ограничений старого класса
java.util.Date. Но с появлением класса
LocalDateTime в Java 8, как части нового API Date-Time, разработчики получили более надежный и интуитивно понятный способ обработки дат.
Как работает класс
java.util.Date? Он представляет собой конкретный момент времени с точностью до миллисекунд и широко используется для манипулирования датой и временем. Однако у него есть ряд недостатков:
Изменяемость: Экземпляры
java.util.Date изменяемы, то есть их можно изменить после создания. Эта изменчивость может привести к непредвиденным последствиям в многопоточных средах. Вот наглядный пример:
import java.util.Date;
public class DateMutationExample {
public static void main(String[] args) {
// Создание нового экземпляра
Date date = new Date();
// Отображение исходной даты
System.out.println("Original Date: " + date);
// Изменяем дату, добавляя 1 день
date.setDate(date.getDate() + 1);
// Отображение измененной даты
System.out.println("Mutated Date: " + date);
}
}
Вывод:
Original Date: Fri Feb 18 09:28:38 UTC 2024
Mutated Date: Sat Feb 19 09:28:38 UTC 2024
Устаревшие методы: Многие методы в
java.util.Date, такие как
getYear(),
getMonth() и
getDate(), устарели из-за различных проблем, включая месяцы и годы, отсчитываемые от нуля, начиная с 1900 года. Пример кода:
import java.util.Date;
public class ZeroBasedMonthExample {
public static void main(String[] args) {
// Создание нового экземпляра
Date date = new Date(2024 - 1900, 0, 15); // 2024-01-15 (January 15, 2024)
// Отображение даты
System.out.println("Date: " + date);
}
}
Вывод:
Date: Wed Jan 15 00:00:00 UTC 2024
Класс
LocalDateTime был представлен в Java 8, он представляет дату и время без часового пояса. Этот класс неизменяем и имеет более интуитивно понятный и удобный API по сравнению с
java.util.Date. Некоторые ключевые преимущества
LocalDateTime включают в себя:
Неизменяемость: экземпляры
LocalDateTime являются неизменяемыми, то есть их нельзя изменить после создания. Это обеспечивает потокобезопасность и снижает риск непредвиденных побочных эффектов.
Ясность и читаемость: LocalDateTime предоставляет четкие и краткие методы для распространенных операций, таких как добавление или вычитание дней, месяцев или лет. Например,
LocalDateTime.plusDays(7) добавляет к текущей дате 7 дней, улучшая читаемость кода.
Варианты использования
- java.util.Date: несмотря на свои недостатки, java.util.Date по-прежнему широко распространен в устаревших базах кода и API. Он может подойти для сценариев, где важна обратная совместимость, или при взаимодействии с внешними системами, которые ожидают объекты java.util.Date.
- LocalDateTime: Этот класс является предпочтительным выбором для новых разработок и современных приложений Java. Он превосходен в сценариях, где важны компоненты даты и времени.
Особенности миграции
При переходе с
java.util.Date на LocalDateTime разработчикам следует внимательно просмотреть существующий код и заменить использование
java.util.Date на
LocalDateTime везде, где это возможно. Очень важно обновить любую логику обработки дат, чтобы использовать расширенные функции
LocalDateTime, такие как улучшенная читаемость и безопасность типов.
Пример преобразования
java.util.Date в
LocalDateTime:
Date date = new Date(); // Предполагаем, что у вас есть объект java.util.Date object
LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
Заключение
В области обработки даты и времени
LocalDateTime представляет собой значительный шаг вперед по сравнению с традиционным классом
java.util.Date. Благодаря неизменности, ясности и поддержке часовых поясов
LocalDateTime упрощает работу с датами и снижает риск ошибок. Хотя
java.util.Date остается актуальным в устаревших системах, разработчикам рекомендуется использовать
LocalDateTime для новых разработок. Это позволит им воспользоваться преимуществами современного API и улучшенным удобством использования. Используя
LocalDateTime, разработчики Java могут писать более надежный, удобный в обслуживании и интуитивно понятный код, связанный с датами.
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ