Кава-брейк #217. Як ініціалізувати List Java. 7 простих прийомів для підвищення продуктивності в Java: поради та приклади

Як ініціалізувати List у Java

Джерело: FreeCodeCamp У цій статті розглядаються різні методи ініціалізації List Java з прикладами практичного використання. Однією з основних структур даних у мові Java є список ( List ). Він дозволяє розробникам зберігати набір елементів та керувати ними. Ініціалізація List в Java - важливий етап процесу розробки, оскільки він визначає початковий стан List і готує його до подальших операцій. Існують різні способи ініціалізації List Java, їх вибір залежить від конкретних вимог проекту:

• Використання конструктора ArrayList .
• Використання методу add() .
• Використання методу Arrays.asList() .
• Використання методу Stream.of() .

Давайте докладно розглянемо ці способи.

Як ініціалізувати список за допомогою конструктора ArrayList

У Java клас ArrayList є реалізацію інтерфейсу динамічного масиву List , що дозволяє додавати і видаляти елементи зі списку в міру необхідності. Клас ArrayList надає кілька конструкторів для створення екземпляра класу. Синтаксис для створення об'єкта ArrayList без початкової ємності:

ArrayList<Object> list = new ArrayList<Object>();

Конструктор без аргументів створює порожній список ( List ) з початковою ємністю 10 елементів. Якщо список перевищує цю місткість, то ArrayList автоматично збільшує місткість, створюючи новий масив більшого розміру і копіюючи елементи зі старого масиву в новий масив. В якості альтернативи ми можемо створити об'єкт ArrayList з початковою місткістю, використовуючи конструктор з одним цілим (integer) аргументом, де capacity початкова ємність списку:

ArrayList<Object> list = new ArrayList<Object>(capacity);

Щоб ініціалізувати List зі значеннями, ми можемо використовувати конструктор, який приймає Collection як аргумент. У цей конструктор можна передати будь-який об'єкт колекції, що реалізує інтерфейс Collection , наприклад інший ArrayList або LinkedList . Елементи колекції додаються до нового ArrayList у порядку, в якому вони з'являються в колекції. Ось приклад того, як створити ArrayList і ініціалізувати його значення за допомогою конструктора, який приймає Collection :

import java.util.ArrayList;
import java.util.Arrays;

public class Example {
    public static void main(String[] args) {
        // создаем массив целых чисел
        Integer[] array = {1, 2, 3, 4, 5};

        // создаем список из массива
        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(array));

        // печатаем список
        System.out.println(list); // [1, 2, 3, 4, 5]
    }
}

У цьому прикладі ми створюємо масив цілих чисел, потім передаємо його методу Arrays.asList() для створення об'єкта List . Потім ми передаємо цей об'єкт List конструктору ArrayList , щоб створити новий ArrayList з тими самими елементами, що й вихідний масив. І, нарешті, ми друкуємо вміст списку, використовуючи метод System.out.println() .

Як ініціалізувати List за допомогою методу add()

Метод add() широко використовується Java для додавання елементів до колекції або списку. Цей метод доступний для кількох типів колекцій Java, включаючи List , Set і Map . Метод add() приймає один аргумент - елемент, який потрібно додати до колекції. Коли йдеться про додавання елементів до vList , метод add() особливо корисний, оскільки списки Java — це впорядковані колекції, які можуть містити дублікати. Метод add() можна використовувати для додавання елементів до кінця списку, що робить його зручним способом ініціалізації List з деякими початковими значеннями. Ось приклад того, як використовувати метод add() для ініціалізації List Java:

import java.util.ArrayList;
import java.util.List;

public class ListExample {
    public static void main(String[] args) {
        // создаем новый ArrayList
        List<String> myList = new ArrayList<>();

        // добавляем элементы в список, используя метод the add()
        myList.add("apple");
        myList.add("banana");
        myList.add("cherry");

        // печатаем содержимое списка
        System.out.println(myList);
    }
}

У цьому прикладі ми спочатку створюємо новий список ArrayList з ім'ям myList . Потім ми використовуємо метод add() для додавання трьох рядків ("apple", "banana" та "cherry") до кінця списку. Потім друкуємо вміст списку, використовуючи метод System.out.println() . Коли ми запустимо програму, висновок буде таким:

Як ініціалізувати List за допомогою методу Arrays.asList()

Вбудований Java метод Arrays.asList() перетворює масив в список. Цей метод приймає масив як аргумент і повертає об'єкт List . Об'єкт, що повертається методом Arrays.asList() , є список фіксованого розміру, що означає, що ми не можемо додавати або видаляти елементи з нього. Щоб використовувати метод Arrays.asList() для ініціалізації List у Java, ми повинні виконати такі кроки: Спочатку оголосимо масив елементів, якими хочемо ініціалізувати список. Наприклад, припустимо, що ми хочемо ініціалізувати список трьома елементами: "apple", "banana" та "orange". Тут ми можемо оголосити масив так:

String[] fruits = {"apple", "banana", "orange"};

Потім викликаємо метод Arrays.asList() і передаємо масив як аргумент. Це поверне об'єкт List , який містить елементи масиву.

List<String> fruitList = Arrays.asList(fruits);

Тепер ми можемо використовувати fruitList для доступу до елементів списку. Наприклад, ми можемо пройтись по списку і роздрукувати кожен елемент:

for (String fruit : fruitList) {
    System.out.println(fruit);
}

Висновок: Важливо, що метод Arrays.asList() не створює новий об'єкт List , а повертає уявлення вихідного масиву у вигляді об'єкта List . Це означає, що якщо змінимо вихідний масив, зміни також будуть відображені в об'єкті List . Наприклад:

fruits[0] = "pear";
System.out.println(fruitList.get(0)); // Вывод: pear

У наведеному вище прикладі змінабо перший елемент масиву fruits на "pear". Коли ми звертаємося до першого елемента об'єкта fruitList , ми також отримуємо "pear", тому що fruitList це просто уявлення масиву fruits .

Як ініціалізувати List за допомогою методу Stream.of()

Stream.of() - це зручний метод, що надається Java 8 і пізнішими версіями в пакеті java.util.stream . Він використовується для створення потоку елементів будь-якого типу, включаючи примітивні типи, масиви та об'єкти. Цей метод приймає один або кілька аргументів та повертає потік, що складається з цих аргументів. Синтаксис методу Stream.of() :

Stream<T> stream = Stream.of(t1, t2, t3, ..., tn);

Тут T - тип елементів у потоці, а t1 і далі до tn - елементи, які повинні бути включені до потоку. Щоб ініціалізувати List Java за допомогою методу Stream.of() , потрібно виконати такі дії:

1. Спочатку імпортуйте пакет java.util.stream .

2. Потім за допомогою конструктора створіть список потрібного типу ArrayList, наприклад:

   List<String> myList = new ArrayList<>();

3. Ініціалізуйте список за допомогою методу Stream.of() , передавши потрібні елементи як аргументи, а потім використовуйте метод collect() для збору елементів потоку до списку, наприклад:

   myList = Stream.of("Apple", "Banana", "Cherry", "Date")
                 .collect(Collectors.toList());

4. Потім ми можемо надрукувати список, щоб перевірити його вміст.

   System.out.println(myList);

   Висновок:

   [Apple, Banana, Cherry, Date]

Висновок

Ініціалізація List в Java - досить проста задача в програмуванні, і існує кілька способів її виконання. Наслідуючи кроки, описані в цій статті, ми можемо легко створити та ініціалізувати List з потрібними елементами, використовуючи метод Stream.of() . Цей підхід є коротким та гнучким, і він може бути особливо корисним, коли нам потрібно ініціалізувати список з невеликою кількістю елементів. Вдалого кодування!

7 простих прийомів для підвищення продуктивності в Java: поради та приклади

Джерело: Medium Вашій увазі пропонується добірка із семи практичних порад, дотримання яких допоможе підвищити продуктивність роботи Java-розробника. Продуктивність Java-додатків можна підвищити, дотримуючись кількох простих порад.

1. Використовуйте примітивні типи замість об'єктів:

// Плохо: использование об'єкта Integer
Integer count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

// Хорошо: использование примитива int
int count = 0;
for (int i = 0; i < 1000000; i++) {
    count++;
}

2. Уникайте створення непотрібних об'єктів:

// Плохо: использование конкатенации строк с помощью '+'
String str = "";
for (int i = 0; i < 10000; i++) {
    str += i;
}

// Хорошо: использование StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sb.append(i);
}
String str = sb.toString();

3. Використовуйте правильну структуру даних:

// Плохо: использование List для частого поиска
List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

// Хорошо: использование HashSet для частого поиска
Set<String> names = new HashSet<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// ...
if (names.contains("Charlie")) {
    // ...
}

4. Мінімізуйте виклики методів:

// Плохо: вызов метода внутри цикла
for (int i = 0; i < 1000000; i++) {
    doSomething(i);
}

// Хорошо: выносим метод за пределы цикла
for (int i = 0; i < 1000000; i++) {
    // ...
}
doSomething(i);

5. Використовуйте статичні (static) та фінальні (final) модифікатори:

// Плохо: создание ненужных экземпляров об'єктов
public class MyClass {
    private int value;
    public void setValue(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass();
obj.setValue(10);
int value = obj.getValue();

// Хорошо: использование статических и финальных модификаторов
public class MyClass {
    private static final int DEFAULT_VALUE = 0;
    private final int value;
    public MyClass(int value) {
        this.value = value;
    }
    public int getValue() {
        return value;
    }
}
MyClass obj = new MyClass(10);
int value = obj.getValue();

6. Використовуйте відповідний алгоритм ситуації:

// Плохо: использовать линейный поиск для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
for (int i = 0; i < nums.size(); i++) {
    if (nums.get(i) == target) {
        // ...
    }
}
// Хорошо: использование бинарного поиска для большой коллекции
List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
// ...
int target = 7;
int index = Collections.binarySearch(nums, target);
if (index >= 0) {
    // ...
}

7. Оптимізуйте цикли:

// Плохо: вызов метода внутри цикла
for (int i = 0; i< 1000000; i++) {
    String str = getString(i);
    // ...
}

// Хорошо: минимизация вызовов методов в цикле
for (int i = 0; i < 1000000; i++) {
    String str = "String " + i;
    // ...
}

Це були лише кілька простих прийомів Java, які можуть підвищити вашу продуктивність. Майте на увазі, що оптимізація продуктивності може бути складним завданням, і розробник часто доводиться аналізувати свій код для виявлення вузьких місць у продуктивності.