Pausa para café #217. Como inicializar lista em Java. 7 truques simples para melhorar a produtividade Java: dicas e exemplos

Como inicializar lista em Java

Fonte: FreeCodeCamp Este artigo aborda vários métodos de inicialização de lista em Java com exemplos práticos. Uma das estruturas de dados básicas da linguagem Java é a List . Ele permite que os desenvolvedores armazenem e gerenciem um conjunto de elementos. Inicializar uma Lista em Java é uma etapa importante no processo de desenvolvimento porque define o estado inicial da Lista e a prepara para operações posteriores. Existem várias formas de inicializar uma Lista em Java, a escolha depende dos requisitos específicos do projeto:

• Usando o construtor ArrayList .
• Usando o método add() .
• Usando o método Arrays.asList() .
• Usando o método Stream.of() .

Vamos dar uma olhada nesses métodos.

Como inicializar uma lista usando o construtor ArrayList

Em Java, a classe ArrayList é uma implementação da interface de array dinâmico List , permitindo adicionar e remover elementos de uma lista conforme necessário. A classe ArrayList fornece vários construtores para criar uma instância da classe. A sintaxe para criar um objeto ArrayList sem capacidade inicial é:

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

O construtor sem argumento cria uma lista vazia ( List ) com capacidade inicial de 10 elementos. Se a lista exceder essa capacidade, a classe ArrayList aumenta automaticamente a capacidade criando um novo array maior e copiando os elementos do array antigo para o novo array. Alternativamente, podemos criar um objeto ArrayList com capacidade inicial usando um construtor com um argumento inteiro, onde capacidade é a capacidade inicial da lista:

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

Para inicializar uma Lista com valores, podemos usar um construtor que recebe uma Coleção como argumento. Você pode passar qualquer objeto de coleção que implemente a interface Collection para esse construtor , como outro ArrayList ou LinkedList . Os elementos da coleção são adicionados ao novo ArrayList na ordem em que aparecem na coleção. Aqui está um exemplo de como criar um ArrayList e inicializá-lo com valores usando um construtor que recebe um 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]
    }
}

Neste exemplo, criamos um array de inteiros e depois o passamos para o método Arrays.asList() para criar um objeto List . Em seguida, passamos esse objeto List para o construtor ArrayList para criar um novo ArrayList com os mesmos elementos do array original. Por fim, imprimimos o conteúdo da lista usando o método System.out.println() .

Como inicializar List usando o método add()

O método add() é amplamente utilizado em Java para adicionar elementos a uma coleção ou lista. Este método está disponível para vários tipos de coleção em Java, incluindo List , Set e Map . O método add() recebe um argumento – o elemento a ser adicionado à coleção. Quando se trata de adicionar elementos a um vList , o método add() é especialmente útil porque as listas em Java são coleções ordenadas que podem conter duplicatas. O método add() pode ser usado para adicionar elementos ao final de uma lista, tornando-o uma maneira conveniente de inicializar uma lista com alguns valores iniciais. Aqui está um exemplo de como usar o método add() para inicializar uma lista em 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);
    }
}

Neste exemplo, primeiro criamos um novo ArrayList denominado myList . Em seguida, usamos o método add() para adicionar três strings (“maçã”, “banana” e “cereja”) ao final da lista. Em seguida, imprimimos o conteúdo da lista usando o método System.out.println() . Quando executarmos o programa, a saída será assim:

Como inicializar List usando o método Arrays.asList()

O método Arrays.asList() integrado do Java converte um array em uma lista. Este método recebe um array como argumento e retorna um objeto List . O objeto retornado pelo método Arrays.asList() é uma lista de tamanho fixo, o que significa que não podemos adicionar ou remover elementos dela. Para usar o método Arrays.asList() para inicializar uma Lista em Java, temos que seguir os seguintes passos: Primeiro, vamos declarar um array de elementos com os quais queremos inicializar a lista. Por exemplo, suponha que queiramos inicializar uma lista com três elementos: “maçã”, “banana” e “laranja”. Aqui podemos declarar um array como este:

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

Em seguida, chamamos o método Arrays.asList() e passamos o array como argumento. Isso retornará um objeto List contendo os elementos do array.

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

Agora podemos usar o objeto frutaList para acessar os elementos da lista. Por exemplo, podemos percorrer uma lista e imprimir cada elemento:

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

Conclusão: É importante observar que o método Arrays.asList() não cria um novo objeto List , mas retorna uma representação do objeto List do array original . Isso significa que se alterarmos o array original, as alterações também serão refletidas no objeto List . Por exemplo:

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

No exemplo acima, alteramos o primeiro elemento do array de frutas para “pêra”. Quando acessamos o primeiro elemento do objeto FruitList , também obtemos "pear" porque FruitList é simplesmente uma representação do array Fruits .

Como inicializar List usando o método Stream.of()

Stream.of() é um método conveniente fornecido pelo Java 8 e posterior no pacote java.util.stream . É usado para criar um fluxo de elementos de qualquer tipo, incluindo tipos primitivos, arrays e objetos. Este método recebe um ou mais argumentos e retorna um fluxo que consiste nesses argumentos. Sintaxe do método Stream.of() :

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

Aqui T é o tipo de elementos no fluxo, e t1 e até tn são os elementos que devem ser incluídos no fluxo. Para inicializar uma lista em Java usando o método Stream.of() , você precisa fazer o seguinte:

1. Primeiro importe o pacote java.util.stream .

2. Em seguida, use o construtor para criar uma lista do tipo ArrayList desejado, por exemplo:

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

3. Inicialize a lista usando o método Stream.of() , passando os elementos desejados como argumentos, e então use o método collect() para coletar os elementos do fluxo em uma lista, por exemplo:

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

4. Podemos então imprimir a lista para verificar seu conteúdo.

   System.out.println(myList);

   Conclusão:

   [Maçã, Banana, Cereja, Tâmara]

Conclusão

Inicializar uma lista em Java é uma tarefa de programação bastante comum e há várias maneiras de fazer isso. Seguindo as etapas descritas neste artigo, podemos facilmente criar e inicializar uma Lista com os elementos desejados usando o método Stream.of() . Esta abordagem é concisa e flexível e pode ser especialmente útil quando precisamos inicializar uma lista com um pequeno número de elementos. Boa codificação!

7 truques simples para melhorar a produtividade Java: dicas e exemplos

Fonte: Medium Aqui está uma seleção de sete dicas práticas que, se seguidas, ajudarão a melhorar a produtividade de um desenvolvedor Java. Você pode melhorar o desempenho de seus aplicativos Java seguindo algumas dicas simples.

1. Use tipos primitivos em vez de objetos:

// Плохо: использование 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. Evite criar objetos desnecessários:

// Плохо: использование конкатенации строк с помощью '+'
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. Use a estrutura de dados correta:

// Плохо: использование 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. Minimize chamadas de método:

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

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

5. Use modificadores estáticos e finais:

// Плохо: создание ненужных экземпляров 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. Utilize um algoritmo adequado à situação:

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

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

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

Esses foram apenas alguns truques simples de Java que podem melhorar sua produtividade. Tenha em mente que otimizar o desempenho pode ser um desafio, e um desenvolvedor muitas vezes precisará analisar seu código para identificar gargalos de desempenho.