Pausa caffè #217. Come inizializzare l'elenco in Java. 7 semplici trucchi per migliorare la produttività Java: suggerimenti ed esempi

Come inizializzare l'elenco in Java

Fonte: FreeCodeCamp Questo articolo tratta vari metodi di inizializzazione degli elenchi in Java con esempi pratici. Una delle strutture dati di base nel linguaggio Java è la List . Consente agli sviluppatori di archiviare e gestire una serie di elementi. L'inizializzazione di una Lista in Java è un passo importante nel processo di sviluppo perché definisce lo stato iniziale della Lista e la prepara per ulteriori operazioni. Esistono vari modi per inizializzare una Lista in Java, la scelta dipende dalle esigenze specifiche del progetto:

• Utilizzando il costruttore ArrayList .
• Utilizzando il metodo add() .
• Utilizzando il metodo Arrays.asList() .
• Utilizzando il metodo Stream.of() .

Diamo uno sguardo più da vicino a questi metodi.

Come inizializzare un elenco utilizzando il costruttore ArrayList

In Java, la classe ArrayList è un'implementazione dell'interfaccia di array dinamico List , che consente di aggiungere e rimuovere elementi da un elenco secondo necessità. La classe ArrayList fornisce diversi costruttori per creare un'istanza della classe. La sintassi per creare un oggetto ArrayList senza una capacità iniziale è:

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

Il costruttore senza argomenti crea una lista vuota ( List ) con una capacità iniziale di 10 elementi. Se l'elenco supera questa capacità, la classe ArrayList aumenta automaticamente la capacità creando un nuovo array più grande e copiando gli elementi dal vecchio array al nuovo array. In alternativa, possiamo creare un oggetto ArrayList con una capacità iniziale utilizzando un costruttore con un argomento intero, dove capacità è la capacità iniziale dell'elenco:

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

Per inizializzare una Lista con valori, possiamo usare un costruttore che accetta una Collezione come argomento. È possibile passare qualsiasi oggetto raccolta che implementi l' interfaccia Collection a questo costruttore , ad esempio un altro ArrayList o LinkedList . Gli elementi della raccolta vengono aggiunti al nuovo ArrayList nell'ordine in cui appaiono nella raccolta. Ecco un esempio di come creare un ArrayList e inizializzarlo con valori utilizzando un costruttore che accetta una 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]
    }
}

In questo esempio creiamo un array di numeri interi e poi lo passiamo al metodo Arrays.asList() per creare un oggetto List . Passiamo quindi questo oggetto List al costruttore ArrayList per creare un nuovo ArrayList con gli stessi elementi dell'array originale. Infine, stampiamo il contenuto della lista utilizzando il metodo System.out.println() .

Come inizializzare l'elenco utilizzando il metodo add()

Il metodo add() è ampiamente utilizzato in Java per aggiungere elementi a una raccolta o a un elenco. Questo metodo è disponibile per diversi tipi di raccolta in Java, inclusi List , Set e Map . Il metodo add() accetta un argomento: l'elemento da aggiungere alla raccolta. Quando si tratta di aggiungere elementi a una vList , il metodo add() è particolarmente utile perché le liste in Java sono raccolte ordinate che possono contenere duplicati. Il metodo add() può essere utilizzato per aggiungere elementi alla fine di una lista, rendendolo un modo conveniente per inizializzare una lista con alcuni valori iniziali. Ecco un esempio di come utilizzare il metodo add() per inizializzare una lista in 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);
    }
}

In questo esempio, creiamo prima un nuovo ArrayList denominato myList . Utilizziamo quindi il metodo add() per aggiungere tre stringhe ("mela", "banana" e "ciliegia") alla fine dell'elenco. Stampiamo quindi il contenuto dell'elenco utilizzando il metodo System.out.println() . Quando eseguiamo il programma, l'output sarà così:

Come inizializzare l'elenco utilizzando il metodo Arrays.asList()

Il metodo Arrays.asList() integrato in Java converte un array in un elenco. Questo metodo accetta un array come argomento e restituisce un oggetto List . L'oggetto restituito dal metodo Arrays.asList() è un elenco di dimensioni fisse, il che significa che non possiamo aggiungere o rimuovere elementi da esso. Per utilizzare il metodo Arrays.asList() per inizializzare una Lista in Java, dobbiamo seguire i seguenti passi: Innanzitutto, dichiariamo un array di elementi con cui vogliamo inizializzare la lista. Ad esempio, supponiamo di voler inizializzare una lista con tre elementi: "mela", "banana" e "arancia". Qui possiamo dichiarare un array come questo:

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

Quindi chiamiamo il metodo Arrays.asList() e passiamo l'array come argomento. Ciò restituirà un oggetto List contenente gli elementi dell'array.

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

Ora possiamo utilizzare l' oggetto fruitList per accedere agli elementi della lista. Ad esempio, possiamo scorrere un elenco e stampare ciascun elemento:

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

Conclusione: È importante notare che il metodo Arrays.asList() non crea un nuovo oggetto List , ma restituisce piuttosto una rappresentazione dell'oggetto List dell'array originale . Ciò significa che se modifichiamo l'array originale, le modifiche si rifletteranno anche nell'oggetto List . Per esempio:

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

Nell'esempio sopra, abbiamo cambiato il primo elemento dell'array di frutti in "pera". Quando accediamo al primo elemento dell'oggetto fruitList , otteniamo anche "pera" perché fruitList è semplicemente una rappresentazione dell'array frutti .

Come inizializzare List utilizzando il metodo Stream.of()

Stream.of() è un metodo pratico fornito da Java 8 e versioni successive nel pacchetto java.util.stream . Viene utilizzato per creare un flusso di elementi di qualsiasi tipo, inclusi tipi primitivi, array e oggetti. Questo metodo accetta uno o più argomenti e restituisce un flusso costituito da tali argomenti. Sintassi del metodo Stream.of() :

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

Qui T è il tipo di elementi nello stream e t1 e fino a tn sono gli elementi che dovrebbero essere inclusi nello stream. Per inizializzare una lista in Java utilizzando il metodo Stream.of() , è necessario effettuare le seguenti operazioni:

1. Per prima cosa importa il pacchetto java.util.stream .

2. Quindi utilizzare il costruttore per creare un elenco del tipo ArrayList desiderato, ad esempio:

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

3. Inizializza l'elenco utilizzando il metodo Stream.of() , passando gli elementi desiderati come argomenti, quindi utilizza il metodo Collect() per raccogliere gli elementi dello stream in un elenco, ad esempio:

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

4. Possiamo quindi stampare l'elenco per verificarne il contenuto.

   System.out.println(myList);

   Conclusione:

   [Mela, Banana, Ciliegia, Dattero]

Conclusione

Inizializzare un elenco in Java è un'attività di programmazione abbastanza comune ed esistono diversi modi per farlo. Seguendo i passaggi descritti in questo articolo, possiamo facilmente creare e inizializzare una Lista con gli elementi desiderati utilizzando il metodo Stream.of() . Questo approccio è conciso e flessibile e può essere particolarmente utile quando dobbiamo inizializzare una lista con un numero limitato di elementi. Buona programmazione!

7 semplici trucchi per migliorare la produttività Java: suggerimenti ed esempi

Fonte: Medium Ecco una selezione di sette consigli pratici che, se seguiti, aiuteranno a migliorare la produttività di uno sviluppatore Java. Puoi migliorare le prestazioni delle tue applicazioni Java seguendo alcuni semplici suggerimenti.

1. Usa i tipi primitivi invece degli oggetti:

// Плохо: использование an object 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. Evita di creare oggetti non necessari:

// Плохо: использование конкатенации строк с помощью '+'
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. Utilizza la struttura dati corretta:

// Плохо: использование 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. Ridurre al minimo le chiamate ai metodi:

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

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

5. Utilizza i modificatori statici e finali:

// Плохо: создание ненужных экземпляров an objectов
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. Utilizzare un algoritmo appropriato alla situazione:

// Плохо: использовать линейный поиск для большой коллекции
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. Ottimizza i tuoi cicli:

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

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

Questi erano solo alcuni semplici trucchi Java che possono migliorare la tua produttività. Tieni presente che l'ottimizzazione delle prestazioni può essere complessa e uno sviluppatore dovrà spesso analizzare il proprio codice per identificare i colli di bottiglia delle prestazioni.