Kaffeepause Nr. 217. So initialisieren Sie eine Liste in Java. 7 einfache Tricks zur Verbesserung der Java-Produktivität: Tipps und Beispiele

So initialisieren Sie eine Liste in Java

Quelle: FreeCodeCamp Dieser Artikel behandelt verschiedene Listeninitialisierungsmethoden in Java mit praktischen Beispielen. Eine der grundlegenden Datenstrukturen in der Java-Sprache ist die Liste . Es ermöglicht Entwicklern, eine Reihe von Elementen zu speichern und zu verwalten. Das Initialisieren einer Liste in Java ist ein wichtiger Schritt im Entwicklungsprozess, da es den Anfangszustand der Liste definiert und sie für weitere Vorgänge vorbereitet. Es gibt verschiedene Möglichkeiten , eine Liste in Java zu initialisieren. Die Auswahl hängt von den spezifischen Anforderungen des Projekts ab:

• Verwendung des ArrayList- Konstruktors .
• Verwenden der add()- Methode .
• Verwenden der Methode Arrays.asList() .
• Verwenden der Stream.of() -Methode .

Schauen wir uns diese Methoden genauer an.

So initialisieren Sie eine Liste mit dem ArrayList-Konstruktor

In Java ist die ArrayList- Klasse eine Implementierung der dynamischen Array-Schnittstelle List , mit der Sie nach Bedarf Elemente zu einer Liste hinzufügen und daraus entfernen können. Die ArrayList- Klasse stellt mehrere Konstruktoren zum Erstellen einer Instanz der Klasse bereit. Die Syntax zum Erstellen eines ArrayList- Objekts ohne Anfangskapazität lautet:

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

Der Konstruktor ohne Argumente erstellt eine leere Liste ( List ) mit einer anfänglichen Kapazität von 10 Elementen. Wenn die Liste diese Kapazität überschreitet, erhöht die ArrayList- Klasse automatisch die Kapazität, indem sie ein neues, größeres Array erstellt und die Elemente aus dem alten Array in das neue Array kopiert. Alternativ können wir ein ArrayList- Objekt mit einer Anfangskapazität erstellen, indem wir einen Konstruktor mit einem ganzzahligen Argument verwenden, wobei Kapazität die Anfangskapazität der Liste ist :

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

Um eine Liste mit Werten zu initialisieren, können wir einen Konstruktor verwenden, der eine Sammlung als Argument verwendet. Sie können jedes Sammlungsobjekt, das die Sammlungsschnittstelle implementiert, an diesen Konstruktor übergeben , beispielsweise eine andere ArrayList oder LinkedList . Die Elemente der Sammlung werden der neuen ArrayList in der Reihenfolge hinzugefügt, in der sie in der Sammlung erscheinen. Hier ist ein Beispiel dafür, wie man eine ArrayList erstellt und sie mithilfe eines Konstruktors, der eine Collection akzeptiert, mit Werten initialisiert :

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 diesem Beispiel erstellen wir ein Array von Ganzzahlen und übergeben es dann an die Methode Arrays.asList() , um ein List- Objekt zu erstellen . Anschließend übergeben wir dieses List- Objekt an den ArrayList -Konstruktor , um eine neue ArrayList mit denselben Elementen wie das ursprüngliche Array zu erstellen. Abschließend drucken wir den Inhalt der Liste mit der Methode System.out.println() aus .

So initialisieren Sie eine Liste mit der Methode add()

Die Methode add() wird in Java häufig verwendet, um Elemente zu einer Sammlung oder Liste hinzuzufügen. Diese Methode ist für mehrere Sammlungstypen in Java verfügbar, einschließlich List , Set und Map . Die Methode add() benötigt ein Argument – ​​das Element, das der Sammlung hinzugefügt werden soll. Wenn es darum geht, Elemente zu einer vList hinzuzufügen , ist die Methode add() besonders nützlich, da Listen in Java geordnete Sammlungen sind, die Duplikate enthalten können. Mit der Methode add() können Elemente am Ende einer Liste hinzugefügt werden. Dies ist eine praktische Möglichkeit, eine Liste mit einigen Anfangswerten zu initialisieren. Hier ist ein Beispiel für die Verwendung der add()- Methode zum Initialisieren einer Liste 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 diesem Beispiel erstellen wir zunächst eine neue ArrayList mit dem Namen myList . Anschließend verwenden wir die Methode add() , um drei Zeichenfolgen („apple“, „banana“ und „cherry“) am Ende der Liste hinzuzufügen. Anschließend drucken wir den Inhalt der Liste mit der Methode System.out.println() aus . Wenn wir das Programm ausführen, sieht die Ausgabe so aus:

So initialisieren Sie eine Liste mit der Methode Arrays.asList()

Die in Java integrierte Methode Arrays.asList() wandelt ein Array in eine Liste um. Diese Methode verwendet ein Array als Argument und gibt ein List- Objekt zurück . Das von der Methode Arrays.asList() zurückgegebene Objekt ist eine Liste fester Größe, was bedeutet, dass wir ihr keine Elemente hinzufügen oder daraus entfernen können. Um die Methode Arrays.asList() zum Initialisieren einer Liste in Java zu verwenden, müssen wir die folgenden Schritte ausführen: Zuerst deklarieren wir ein Array von Elementen, mit denen wir die Liste initialisieren möchten. Angenommen, wir möchten eine Liste mit drei Elementen initialisieren: „Apfel“, „Banane“ und „Orange“. Hier können wir ein Array wie folgt deklarieren:

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

Dann rufen wir die Methode Arrays.asList() auf und übergeben das Array als Argument. Dadurch wird ein List- Objekt zurückgegeben , das die Elemente des Arrays enthält.

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

Jetzt können wir das Objekt „fruitList“ verwenden , um auf die Elemente der Liste zuzugreifen. Beispielsweise können wir eine Liste durchlaufen und jedes Element ausdrucken:

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

Abschluss: Es ist wichtig zu beachten, dass die Methode Arrays.asList() kein neues List- Objekt erstellt, sondern eine List- Objektdarstellung des ursprünglichen Arrays zurückgibt . Das heißt, wenn wir das ursprüngliche Array ändern, werden die Änderungen auch im List- Objekt widergespiegelt . Zum Beispiel:

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

Im obigen Beispiel haben wir das erste Element des Fruit- Arrays in „Pear“ geändert. Wenn wir auf das erste Element des FruitList- Objekts zugreifen , erhalten wir auch „pear“, da FruitList einfach eine Darstellung des Fruit- Arrays ist .

So initialisieren Sie die Liste mit der Stream.of()-Methode

Stream.of() ist eine praktische Methode, die von Java 8 und höher im Paket java.util.stream bereitgestellt wird . Es wird verwendet, um einen Stream von Elementen beliebiger Art zu erstellen, einschließlich primitiver Typen, Arrays und Objekte. Diese Methode akzeptiert ein oder mehrere Argumente und gibt einen Stream zurück, der aus diesen Argumenten besteht. Syntax der Stream.of() -Methode :

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

Hier ist T der Typ der Elemente im Stream, und t1 und weiter oben bis tn sind die Elemente, die in den Stream aufgenommen werden sollen. Um eine Liste in Java mit der Methode Stream.of() zu initialisieren , müssen Sie Folgendes tun:

1. Importieren Sie zunächst das Paket java.util.stream .

2. Verwenden Sie dann den Konstruktor, um eine Liste des gewünschten ArrayList-Typs zu erstellen, zum Beispiel:

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

3. Initialisieren Sie die Liste mit der Stream.of()- Methode , übergeben Sie die gewünschten Elemente als Argumente und verwenden Sie dann die Collect()- Methode , um die Stream-Elemente in einer Liste zu sammeln, zum Beispiel:

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

4. Wir können die Liste dann ausdrucken, um ihren Inhalt zu überprüfen.

   System.out.println(myList);

   Abschluss:

   [Apfel, Banane, Kirsche, Dattel]

Abschluss

Das Initialisieren einer Liste in Java ist eine ziemlich häufige Programmieraufgabe und es gibt mehrere Möglichkeiten, dies zu tun. Indem wir die in diesem Artikel beschriebenen Schritte befolgen, können wir mithilfe der Stream.of()- Methode ganz einfach eine Liste mit den gewünschten Elementen erstellen und initialisieren . Dieser Ansatz ist prägnant und flexibel und kann besonders nützlich sein, wenn wir eine Liste mit einer kleinen Anzahl von Elementen initialisieren müssen. Viel Spaß beim Codieren!

7 einfache Tricks zur Verbesserung der Java-Produktivität: Tipps und Beispiele

Quelle: Medium Hier finden Sie eine Auswahl von sieben praktischen Tipps, deren Befolgung dazu beitragen wird, die Produktivität eines Java-Entwicklers zu verbessern. Sie können die Leistung Ihrer Java-Anwendungen verbessern, indem Sie ein paar einfache Tipps befolgen.

1. Verwenden Sie primitive Typen anstelle von Objekten:

// Плохо: использование ein Objektа 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. Vermeiden Sie die Erstellung unnötiger Objekte:

// Плохо: использование конкатенации строк с помощью '+'
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. Verwenden Sie die richtige Datenstruktur:

// Плохо: использование 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. Methodenaufrufe minimieren:

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

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

5. Verwenden Sie statische und endgültige Modifikatoren:

// Плохо: создание ненужных экземпляров ein Objektов
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. Verwenden Sie einen der Situation angemessenen Algorithmus:

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

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

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

Dies waren nur ein paar einfache Java-Tricks, die Ihre Produktivität steigern können. Bedenken Sie, dass die Optimierung der Leistung eine Herausforderung sein kann und ein Entwickler häufig seinen Code analysieren muss, um Leistungsengpässe zu identifizieren.