Pausa para el café #217. Cómo inicializar la lista en Java. 7 trucos sencillos para mejorar la productividad de Java: consejos y ejemplos

Cómo inicializar la lista en Java

Fuente: FreeCodeCamp Este artículo cubre varios métodos de inicialización de listas en Java con ejemplos prácticos. Una de las estructuras de datos básicas en el lenguaje Java es la Lista . Permite a los desarrolladores almacenar y gestionar un conjunto de elementos. Inicializar una Lista en Java es un paso importante en el proceso de desarrollo porque define el estado inicial de la Lista y la prepara para operaciones posteriores. Hay varias formas de inicializar una Lista en Java, la elección depende de los requisitos específicos del proyecto:

• Usando el constructor ArrayList .
• Utilizando el método add() .
• Usando el método Arrays.asList() .
• Usando el método Stream.of() .

Echemos un vistazo más de cerca a estos métodos.

Cómo inicializar una lista usando el constructor ArrayList

En Java, la clase ArrayList es una implementación de la interfaz de matriz dinámica List , que le permite agregar y eliminar elementos de una lista según sea necesario. La clase ArrayList proporciona varios constructores para crear una instancia de la clase. La sintaxis para crear un objeto ArrayList sin capacidad inicial es:

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

El constructor sin argumentos crea una lista vacía ( List ) con una capacidad inicial de 10 elementos. Si la lista excede esta capacidad, la clase ArrayList aumenta automáticamente la capacidad creando una matriz nueva y más grande y copiando los elementos de la matriz anterior a la nueva matriz. Alternativamente, podemos crear un objeto ArrayList con una capacidad inicial usando un constructor con un argumento entero, donde capacidad es la capacidad inicial de la lista:

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

Para inicializar una Lista con valores, podemos usar un constructor que tome una Colección como argumento. Puede pasar cualquier objeto de colección que implemente la interfaz Collection a este constructor , como otro ArrayList o LinkedList . Los elementos de la colección se agregan a la nueva ArrayList en el orden en que aparecen en la colección. Aquí hay un ejemplo de cómo crear un ArrayList e inicializarlo con valores usando un constructor que toma una Colección :

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]
    }
}

En este ejemplo, creamos una matriz de números enteros y luego la pasamos al método Arrays.asList() para crear un objeto List . Luego pasamos este objeto List al constructor ArrayList para crear una nueva ArrayList con los mismos elementos que la matriz original. Finalmente, imprimimos el contenido de la lista usando el método System.out.println() .

Cómo inicializar la lista usando el método add()

El método add() se usa ampliamente en Java para agregar elementos a una colección o lista. Este método está disponible para varios tipos de colecciones en Java, incluidos List , Set y Map . El método add() toma un argumento: el elemento que se agregará a la colección. Cuando se trata de agregar elementos a una vList , el método add() es especialmente útil porque las listas en Java son colecciones ordenadas que pueden contener duplicados. El método add() se puede utilizar para agregar elementos al final de una lista, lo que lo convierte en una forma conveniente de inicializar una lista con algunos valores iniciales. Aquí hay un ejemplo de cómo usar el método add() para inicializar una Lista en 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);
    }
}

En este ejemplo, primero creamos una nueva ArrayList llamada myList . Luego usamos el método add() para agregar tres cadenas ("manzana", "plátano" y "cereza") al final de la lista. Luego imprimimos el contenido de la lista usando el método System.out.println() . Cuando ejecutamos el programa, el resultado será así:

Cómo inicializar la Lista usando el método Arrays.asList()

El método incorporado Arrays.asList() de Java convierte una matriz en una lista. Este método toma una matriz como argumento y devuelve un objeto Lista . El objeto devuelto por el método Arrays.asList() es una lista de tamaño fijo, lo que significa que no podemos agregarle ni quitarle elementos. Para utilizar el método Arrays.asList() para inicializar una Lista en Java, tenemos que seguir los siguientes pasos: Primero, declaremos un array de elementos con los que queremos inicializar la lista. Por ejemplo, supongamos que queremos inicializar una lista con tres elementos: "manzana", "plátano" y "naranja". Aquí podemos declarar una matriz como esta:

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

Luego llamamos al método Arrays.asList() y pasamos la matriz como argumento. Esto devolverá un objeto Lista que contiene los elementos de la matriz.

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

Ahora podemos usar el objeto fruitList para acceder a los elementos de la lista. Por ejemplo, podemos recorrer una lista e imprimir cada elemento:

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

Conclusión: Es importante tener en cuenta que el método Arrays.asList() no crea un nuevo objeto List , sino que devuelve una representación del objeto List de la matriz original . Esto significa que si cambiamos la matriz original, los cambios también se reflejarán en el objeto Lista . Por ejemplo:

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

En el ejemplo anterior, cambiamos el primer elemento de la matriz de frutas a "pera". Cuando accedemos al primer elemento del objeto fruitList , también obtenemos "pera" porque fruitList es simplemente una representación de la matriz de frutas .

Cómo inicializar la Lista usando el método Stream.of()

Stream.of() es un método conveniente proporcionado por Java 8 y versiones posteriores en el paquete java.util.stream . Se utiliza para crear un flujo de elementos de cualquier tipo, incluidos tipos primitivos, matrices y objetos. Este método toma uno o más argumentos y devuelve una secuencia que consta de esos argumentos. Sintaxis del método Stream.of() :

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

Aquí T es el tipo de elementos en la secuencia, y t1 y más hasta tn son los elementos que deben incluirse en la secuencia. Para inicializar una Lista en Java usando el método Stream.of() , debe hacer lo siguiente:

1. Primero importe el paquete java.util.stream .

2. Luego use el constructor para crear una lista del tipo ArrayList deseado, por ejemplo:

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

3. Inicialice la lista usando el método Stream.of() , pasando los elementos deseados como argumentos y luego use el método Collect() para recopilar los elementos de la secuencia en una lista, por ejemplo:

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

4. Luego podemos imprimir la lista para comprobar su contenido.

   System.out.println(myList);

   Conclusión:

   [Manzana, Plátano, Cereza, Dátil]

Conclusión

Inicializar una lista en Java es una tarea de programación bastante común y hay varias formas de hacerlo. Siguiendo los pasos descritos en este artículo, podemos crear e inicializar fácilmente una Lista con los elementos deseados usando el método Stream.of() . Este enfoque es conciso y flexible y puede resultar especialmente útil cuando necesitamos inicializar una lista con una pequeña cantidad de elementos. ¡Feliz codificación!

7 trucos sencillos para mejorar la productividad de Java: consejos y ejemplos

Fuente: Medio Aquí hay una selección de siete consejos prácticos que, si se siguen, ayudarán a mejorar la productividad de un desarrollador de Java. Puede mejorar el rendimiento de sus aplicaciones Java siguiendo unos sencillos consejos.

1. Utilice tipos primitivos en lugar de objetos:

// Плохо: использование un objetoа 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. Evite crear objetos innecesarios:

// Плохо: использование конкатенации строк с помощью '+'
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. Utilice la estructura de datos correcta:

// Плохо: использование 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. Minimizar las llamadas a métodos:

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

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

5. Utilice modificadores estáticos y finales:

// Плохо: создание ненужных экземпляров un objetoов
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. Utilice un algoritmo apropiado a la situación:

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

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

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

Estos fueron sólo algunos trucos simples de Java que pueden mejorar su productividad. Tenga en cuenta que optimizar el rendimiento puede ser un desafío y, a menudo, un desarrollador necesitará analizar su código para identificar cuellos de botella en el rendimiento.