🖥 20 приемов работы на Java, которые помогут вам улучшить качество кода

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

1. По возможности отдавайте предпочтение примитивам, а не классам-оболочкам
Long idNumber;
long idNumber; // long занимает меньше памяти, чем Long

2. Попробуйте использовать подходящий тип для вашей переменной

Если два или более типов удовлетворяют вашим функциональным потребностям, используйте тот тип, который занимает меньше места в памяти.

int birthYear;
short birthYear; // лучше, потому что год рождения не может быть пятизначным


int personRunningSpeedKmHour;
byte personRunningSpeedKmHour; // лучше, потому что скорость движения человека ограничена

3. При проверке нечетности числа побитовый оператор AND намного быстрее, чем арифметический оператор по модулю
public boolean isOdd(int num) {
return (num & 1) != 0;
}
// лучший способ проверить нечетность числа

4. Избегайте избыточной инициализации (0, false, null..)
Не инициализируйте переменные с их инициализацией по умолчанию, например, boolean по умолчанию имеет значение false, поэтому избыточно инициализировать его значением false.

String name = null; // избыточно
int speed = 0; // избыточно
boolean isOpen = false; // избыточно


String name;
int speed;
boolean isOpen;
// те же значения в более чистом коде

5. Объявляйте членов класса закрытыми везде, где это возможно, и всегда давайте модификатору доступа максимально ограниченный доступ

public int age; // очень плохо
int age; // плохо
private int age; // хорошо

6. Избегайте использования ключевого слова “new” при создании строки

String s1 = new String("AnyString") ; // плохая реализация
// Конструктор создает новый объект и добавляет литерал в кучу

String s2 = "AnyString" ; // хорошо: быстрое создание экземпляра

// Этот ярлык ссылается на элемент в пуле строк и создает новый объект, только если литерал отсутствует в пуле строк.

7. Для объединения нескольких строк используйте StringBuilder или StringBuffer вместо использования оператора +
Оператор + неэффективен, поскольку компилятор Java создает несколько промежуточных объектов String перед созданием окончательной объединенной строки.

StringBuilder или StringBuffer изменяют String без создания промежуточных объектов String.

String address = streetNumber +" "+ streetName +" "
+cityName+" "+cityNumber+" "+ countryName; // плохо


StringBuilder address = new StringBuilder(streetNumber).append(" ")
.append(streetName).append(" ").append(cityName).append(" ")
.append(cityNumber).append(" ").append(countryName); // хорошо

Учтите, что StringBuilder не потокобезопасен, не синхронизирован, но он быстрее, чем StringBuffer, который потокобезопасен и синхронизирован.

8. Используйте подчеркивание в числовых литералах

int myMoneyInBank = 58356823;
int myMoneyInBank = 58_356_823; // лучше читаемый код

long billsToPay = 1000000000L;
long billsToPay = 1_000_000_000L; // лучше читаемый код

9. Избегайте использования “for loop” с индексами
Не используйте for loop с переменной индекса (или счетчика), если вы можете заменить его расширенным циклом for (начиная с Java 5) или forEach (начиная с Java 8). Это связано с тем, что переменная индекса подвержена ошибкам, поскольку мы можем случайно изменить ее в теле цикла или начать индекс с 1 вместо 0.

for (int i = 0; i < names.length; i++)
{ saveInDb(names[i]); }

for (String name : names)
{ saveInDb(name); } // более чистый код

10. Заменяйте try-catch-finally на try-with-resources

Scanner scanner = null;
try
{scanner = new Scanner(new File("test.txt"));
while (scanner.hasNext())
{System.out.println(scanner.nextLine());}}
catch (FileNotFoundException e)
{e.printStackTrace();}
finally
{if (scanner != null)
{scanner.close();}}
// подвержено ошибкам, так как мы можем забыть закрыть сканер в блоке finally

try (Scanner scanner = new Scanner(new File("test.txt")))
{while (scanner.hasNext())
{System.out.println(scanner.nextLine());}}
catch (FileNotFoundException fnfe)
{fnfe.printStackTrace();}
// чище и более лаконично

▪Читать дальше

🖥 Как перебрать Hashmap с помощью цикла. Понимание Void и Null в Java с примерами

В этом руководстве подробно рассмотрено, как перебирать Hashmap, используя различные типы циклов в Java.

Как перебрать Hashmap в Java с помощью цикла for-each
Один из самых простых способов перебора Hashmap — использование цикла for-each. Вот пример того, как это сделать:

HashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

for (Map.Entry<String, Integer> entry : map.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("Key: " + key + ", Value: " + value);
}

В этом примере мы сначала создаем новый Hashmap и добавляем к нему несколько пар ключ-значение. Затем мы используем цикл for-each для итерации по Hashmap, извлекая каждую пару ключ-значение как объект Map.Entry. Затем мы извлекаем ключ и значение из каждого объекта Map.Entry и выводим их на консоль.

Как выполнить итерацию по Hashmap в Java, используя цикл while с итератором.
Другой способ выполнить итерацию по Hashmap — использовать цикл while с итератором. Перед вами пример того, как это сделать:

HashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Integer> entry = iterator.next();
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println("Key: " + key + ", Value: " + value);
}

Здесь мы снова создаем новый Hashmap и добавляем к нему несколько пар ключ-значение. Затем мы создаем новый объект Iterator с помощью метода entrySet(), который возвращает набор пар ключ-значение в виде объектов Map.Entry. Затем мы используем цикл while с методами hasNext() и next() для перебора набора и извлечения каждой пары ключ-значение. И наконец, мы извлекаем ключ и значение из каждого объекта Map.Entry и выводим их на консоль.

Как перебирать Hashmap Java с помощью for loop с keySet()

В Java метод keySet() — это метод класса java.util.HashMap, который возвращает возвращает установленное представление ключей, содержащихся в Hashmap. Это означает, что он возвращает набор всех ключей в Hashmap, которые можно использовать для перебора ключей или выполнения над ними других операций.

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

Мы также можем перебирать Hashmap, используя цикл for с методом keySet(). Вот пример того, как это выполнить:

ashMap<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);

for (String key : map.keySet()) {
Integer value = map.get(key);
System.out.println("Key: " + key + ", Value: " + value);

В данном примере мы снова создаем новый Hashmap и добавляем к ней несколько пар ключ-значение. Затем мы используем цикл for с методом keySet() для итерации по Hashmap, извлечения каждого ключа и использования его для получения соответствующего значения из Hashmap. Затем мы выводим ключ и значение на консоль.

Читать полностью

@javatg

🖥 Kotlin: вложенный и внутренний классы

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

▪Читать

@javatg

🖥 Error Prone Support

Error Prone Support -- это инструмент статического анализа для Java, который выявляет распространенные ошибки во время компиляции.

Это библиотека является расширенной версии Error Prone с дополнительными средствами проверки ошибок.

🖥 Github
🔍 Документация

#github #java

@javatg

🖥 Сравнение многопоточных и однопоточных операций при копировании памяти в Java. Как избегать NullPointerException, используя возможности Optional

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

▪Читать

@javatg

🖥 8 лучших техник программирования в Kotlin

Данная статья предлагает обзор продвинутых техник программирования в Kotlin.

▪Читать дальше

@javatg

🖥 Реализации шаблона Singleton, которые вы должны знать

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

Ленивая загрузка
Ленивая загрузка (lazy loading) означает, что вы загружаете синглтон только тогда, когда он вам нужен. Иными словами, вы инициируете экземпляр только при вызове getInstance(). То есть, даже если у вас есть другие статические методы в вашем классе Singleton, которые будут, например, загружать конфигурацию, и эти методы используются для запуска вашего приложения, то процесс инициализации все равно ограничен только методом getInstance(). Таким образом, время запуска вашего приложения не будет зависеть от времени загрузки экземпляра.

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

Это простой класс, который можно реализовать там, где у нас есть приватный конструктор, и мы можем вызвать getInstance() для инициализации переменной, если она по-прежнему имеет значение null. Результат должен выглядеть так:

public class Singleton {

private static Singleton instance;

private Singleton() {
}

public static Singleton getInstance() {
if(instance == null){
instance = new Singleton();
}
return instance;
}
}

Синхронизированная отложенная загрузка
Синхронизация может быть немного сложной, поскольку здесь мы можем использовать два разных подхода:

1. Синхронизируем весь метод getInstance().
2. Синхронизируем часть метода.

Давайте реализуем код:

public class ThreadSafeSingleton {

private static ThreadSafeSingleton instance;

private ThreadSafeSingleton() {
}

public static synchronized ThreadSafeSingleton getInstance() {
if(instance == null){
Main.waitTime();
Main.waitTime();
instance = new ThreadSafeSingleton();
}
Main.waitTime();
return instance;
}

public static ThreadSafeSingleton getInstanceOptimized() {
if(instance == null){
synchronized (ThreadSafeSingleton.class){
if(instance == null){
Main.waitTime();
Main.waitTime();
instance = new ThreadSafeSingleton();
}
}
}
Main.waitTime();
return instance;
}
}

▪Читать дальше

@javatg