Pausa para café #196. Como ler arquivos corretamente em Java 8 e Java 11. Como classificar uma lista em Java, vários métodos para classificar listas em Java

Como ler arquivos corretamente em Java 8 e Java 11

Fonte: Médio Com este tutorial, você aprenderá diversas dicas que são úteis ao processar e ler arquivos grandes em Java 8 e Java 11. Ler um arquivo que está localizado no disco do seu computador é bastante simples em Java. No Java 8 e posterior, você pode usar a classe Files para isso . Faz parte do pacote java.nio.file , que foi introduzido pela primeira vez no Java 7 para fornecer uma maneira mais eficiente de trabalhar com arquivos e diretórios. Abaixo está um exemplo de como você pode usar a classe Files para ler um arquivo em Java 8.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Este exemplo usa o método Files.readAllLines() para ler todas as linhas de um arquivo e armazená-las em um arquivo List<String> . O método Paths.get() é usado para criar um objeto Path que representa o arquivo. Além disso, você pode usar Files.lines :

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;

public class FileReader {
    public static void main(String[] args) {
        try {
            Files.lines(Paths.get("file.txt"))
                .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

No Java 11, para ler arquivos você pode usar o método readString() , ele lê o arquivo inteiro como uma string. Aqui está um exemplo de como usá-lo.

import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileReader {
    public static void main(String[] args) {
        try {
            Path path = Paths.get("file.txt");
            String content = Files.readString(path);
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Ao trabalhar com arquivos grandes em Java, é importante manter algumas orientações em mente:

1. Use um leitor com buffer . Ele permite que você leia grandes blocos de dados por vez, em vez de ler um caractere ou uma linha por vez.
2. Use um tamanho de buffer menor : ao usar um leitor com buffer, um tamanho de buffer menor pode ajudar a reduzir o uso de memória.
3. Use a API de streaming . Em vez de carregar o arquivo inteiro na memória, a API de streaming permite ler o arquivo em partes.
4. Use um thread paralelo para processar o arquivo , especialmente se o arquivo for grande.
5. Feche o arquivo após a leitura: isso ajudará a liberar recursos.
6. Use a instrução try-with-resources para fechar automaticamente um arquivo após lê-lo. Isso garante que o arquivo seja fechado mesmo se ocorrer uma exceção durante a leitura.

Abaixo está um exemplo de uso da instrução try-with-resources para ler um arquivo.

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.Files;
import java.util.List;

public class FileReader {
    public static void main(String[] args) {
        try (BufferedReader reader = Files.newBufferedReader(Paths.get("file.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Neste exemplo, um objeto BufferedReader é criado dentro de uma instrução try-with-resources, o que garante que ele seja fechado automaticamente ao sair do bloco, mesmo que ocorra uma exceção. Portanto, ao ler arquivos grandes em Java, é melhor usar um leitor com buffer, tamanho de buffer menor, API de streaming, fluxo paralelo e fechar o arquivo após lê-lo. Além disso, o uso de uma instrução try-with-resources pode ajudar a garantir que o arquivo seja fechado corretamente no caso de uma exceção.

Como classificar uma lista em Java. Vários métodos de classificação de lista em Java

Fonte: FreeCodeCamp Esta postagem cobre vários métodos de classificação de lista em Java: Collections.sort() , stream.sorted() e List.sort() . Às vezes, os dados precisam ser organizados em uma ordem específica para facilitar a compreensão, a localização e o processamento. Chamamos esse processo de classificação. Usando a classificação, você pode organizar os dados não apenas em uma ordem específica, mas também de acordo com critérios: por exemplo, por tipo de dados, incluindo números, strings e objetos. A linguagem Java possui métodos integrados para classificação, por exemplo nas classes Collections . A classificação Java é frequentemente usada em aplicativos de comércio eletrônico onde o usuário precisa exibir uma lista de produtos. Os produtos podem ser classificados de várias maneiras, dependendo dos requisitos definidos pelo usuário, como preço, classificação, marca e assim por diante. Por exemplo, se um usuário quiser ver todos os produtos classificados por preço em ordem crescente, o aplicativo poderá usar um algoritmo de classificação para organizar os produtos nessa ordem. Dessa forma, quando um usuário navegar pelos produtos, ele poderá ver primeiro os produtos mais baratos e tomar a decisão de compra de acordo.

Como usar o método Collections.Sort() em Java

Uma das maneiras mais comuns de classificar dados em Java é usar o método Collections.sort() . Por padrão, ele classifica a lista em ordem crescente. Aqui está um exemplo de uso do método Collections.sort() para classificar uma lista de inteiros:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<Integer>();
        numbers.add(3);
        numbers.add(1);
        numbers.add(4);
        numbers.add(2);

        Collections.sort(numbers);

        System.out.println("Sorted List: " + numbers);
    }
}

O código acima cria uma lista de números inteiros, adiciona quatro números a ela, classifica a lista e, em seguida, imprime a lista classificada no console. Ele usa classes da Java Standard Library para executar operações, incluindo java.util.Collections , java.util.List e java.util.ArrayList . A saída é a seguinte: Você também pode classificar uma lista de objetos personalizados usando o método Collections.sort() . Para fazer isso, você precisará criar um comparador e passá-lo como argumento para o método Collections.sort() . Um comparador é um objeto que implementa a interface java.util.Comparator . Possui um único método que pode ser chamado, compare() , que compara dois objetos e retorna um número inteiro indicando sua ordem relativa. Aqui está um exemplo de como usar um comparador para classificar uma lista de objetos personalizados:

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

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        people.add(new Person("Bob", 30));
        people.add(new Person("Charlie", 20));

        Collections.sort(people, new PersonComparator());

        System.out.println("Sorted List: " + people);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return name + " (" + age + ")";
    }
}

class PersonComparator implements java.util.Comparator<Person> {
    @Override
    public int compare(Person a, Person b) {
        return a.getAge() - b.getAge();
    }
}

O código mostrado acima cria uma lista de objetos Person , adiciona vários objetos Person à lista , classifica a lista usando um comparador personalizado ( PersonComparator ) e, em seguida, imprime a lista classificada. A classe Person possui dois campos, name e age , bem como métodos getter para esses campos. A classe PersonComparator implementa a interface Comparator e substitui o método de comparação para classificar objetos Person por idade ( age ). A saída deste programa será assim: O método Collections.sort() é melhor usado quando você tem uma coleção de objetos que deseja classificar por um ou mais campos. Por exemplo, se você possui uma coleção de objetos Employee e deseja classificá-los por sobrenome, você pode usar o método Collections.sort() e passar um comparador personalizado que compara os sobrenomes dos objetos Employee .

Como usar o método List.Sort() em Java

Este método classifica a lista em ordem crescente. Veja como funciona:

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        numbers.sort(null);
        System.out.println(numbers); // prints [1, 2, 3, 4, 5]
    }
}

Dentro do método principal , Arrays.asList cria uma lista de inteiros chamados números . O código então classifica essa lista de números usando o método sort padrão, já que null é passado para o método sort . Finalmente, a lista classificada é impressa no console usando o método System.out.println . A saída é [1, 2, 3, 4, 5] . List.sort() é útil quando você tem uma lista de elementos que precisam ser classificados. Por exemplo, se você tiver uma lista de strings e quiser classificá-las em ordem alfabética, poderá usar o método List.sort() para fazer isso . List.sort() é um método de instância da classe List e classifica os elementos na ordem determinada por sua ordem natural ou pela implementação do Icomparer fornecida .

Como usar o método stream.sorted() em Java

No Java 8 e posterior, você pode usar a API Stream para classificar uma lista. Ele fornece o método sorted , que pode ser usado para classificar os elementos de um fluxo. Aqui está um exemplo de como classificar uma lista de números inteiros usando um stream:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {

        List<Integer> numbers = Arrays.asList(5, 3, 2, 4, 1);
        List<Integer> sortedList = numbers.stream().sorted().collect(Collectors.toList());
        System.out.println(sortedList); // prints [1, 2, 3, 4, 5]

    }
}

Como você pode ver, a lista de números é convertida em um fluxo usando o método stream() . O método sorted() é então chamado para classificar os elementos no stream . O método collect(Collectors.toList()) é usado para coletar os elementos classificados de volta em uma lista. O resultado é uma nova lista contendo os elementos classificados. A saída é [1, 2, 3, 4, 5] . stream.sorted() é melhor usado quando você tem um fluxo de elementos que precisam ser classificados. Por exemplo, se você tiver um fluxo de números inteiros e quiser classificá-los em ordem crescente, é melhor usar o método stream.Sorted() para isso .

Conclusão

Neste tutorial, você aprendeu que existem várias maneiras de classificar uma lista em Java - o método Collections.sort() , o método stream.sorted() e o método List.sort() . Qual desses métodos é melhor usar depende dos requisitos específicos da tarefa em questão. Espero que este artigo tenha fornecido as informações corretas sobre como classificar uma lista em Java. Boa codificação!