Coffee break #196. How to read files correctly in Java 8 and Java 11. How to sort a List in Java, various methods for sorting lists in Java

How to properly read files in Java 8 and Java 11

Source: Medium With this tutorial, you will learn several tips that are useful when processing and reading large files in Java 8 and Java 11. Reading a file that is located on your computer's disk is quite simple in Java. In Java 8 and later, you can use the Files class for this . It is part of the java.nio.file package , which was first introduced in Java 7 to provide a more efficient way to work with files and directories. Below is an example of how you can use the Files class to read a file in 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();
        }
    }
}

This example uses the Files.readAllLines() method to read all the lines of a file and store them in a List<String> file . The Paths.get() method is used to create a Path object representing the file. Also you can use 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();
        }
    }
}

In Java 11, to read files you can use the readString() method , it reads the entire file as a string. Here's an example of how to use it.

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();
        }
    }
}

When working with large files in Java, it is important to keep some guidelines in mind:

1. Use a buffered reader . It allows you to read large chunks of data at a time, rather than reading one character or one line at a time.
2. Use a smaller buffer size : When using a buffered reader, a smaller buffer size can help reduce memory usage.
3. Use the streaming API . Instead of loading the entire file into memory, the streaming API allows you to read the file in parts.
4. Use a parallel thread to process the file , especially if the file is large.
5. Close the file after reading: this will help free up resources.
6. Use the try-with-resources statement to automatically close a file after reading it. This ensures that the file is closed even if an exception occurs while reading it.

Below is an example of using the try-with-resources statement to read a file.

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();
        }
    }
}

In this example, a BufferedReader object is created inside a try-with-resources statement, which ensures that it is automatically closed when exiting the block, even if an exception occurs. So, when reading large files in Java, it is best to use a buffered reader, smaller buffer size, streaming API, parallel stream, and close the file after reading it. Additionally, using a try-with-resources statement can help ensure that the file is closed correctly in the event of an exception.

How to sort List in Java. Various List Sorting Methods in Java

Source: FreeCodeCamp This post covers various List sorting methods in Java: Collections.sort() , stream.sorted() and List.sort() . Sometimes data needs to be arranged in a specific order to make it easier to understand, find, and process. We call this process sorting. Using sorting, you can organize data not only in a specific order, but also according to criteria: for example, by data type, including numbers, strings, and objects. The Java language has built-in methods for sorting, for example in the Collections classes . Java sorting is often used in e-commerce applications where the user needs to display a list of products. Products can be sorted in various ways depending on the requirements that the user sets, such as price, rating, brand, and so on. For example, if a user wants to see all products sorted by price in ascending order, the application can use a sorting algorithm to arrange the products in that order. This way, when a user browses products, he will be able to see the cheapest products first and make a purchasing decision accordingly.

How to use Collections.Sort() method in Java

One of the most common ways to sort data in Java is to use the Collections.sort() method . By default, it sorts the list in ascending order. Here's an example of using the Collections.sort() method to sort a List of integers:

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);
    }
}

The above code creates a list of integers, adds four numbers to it, sorts the list, and then prints the sorted list to the console. It uses classes from the Java Standard Library to perform operations, including java.util.Collections , java.util.List , and java.util.ArrayList . The output is the following: You can also sort a list of custom objects using the Collections.sort() method . To do this, you will need to create a comparator and pass it as an argument to the Collections.sort() method . A comparator is an object that implements the java.util.Comparator interface . It has a single callable method, compare() , which compares two objects and returns an integer indicating their relative order. Here's an example of how to use a comparator to sort a list of custom objects:

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();
    }
}

The code shown above creates a list of Person objects , adds several Person objects to the list , sorts the list using a custom comparator ( PersonComparator ), and then prints the sorted list. The Person class has two fields, name and age , as well as getter methods for these fields. The PersonComparator class implements the Comparator interface and overrides the comparison method to sort Person objects by age ( age ). The output of this program will be like this: The Collections.sort() method is best used when you have a collection of objects that you want to sort by one or more fields. For example, if you have a collection of Employee objects and you want to sort them by last name, you can use the Collections.sort() method and pass a custom comparator that compares the last names of the Employee objects .

How to use List.Sort() method in Java

This method sorts the list in ascending order. Here's how it works:

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

Inside the main method , Arrays.asList creates a list of integers called numbers . The code then sorts this list of numbers using the default sort method, since null is passed to the sort method . Finally, the sorted list is printed to the console using the System.out.println method . The output is [1, 2, 3, 4, 5] . List.sort() is useful when you have a list of elements that need to be sorted. For example, if you have a list of strings and you want to sort them alphabetically, you can use the List.sort() method to do this . List.sort() is an instance method of the List class and sorts the elements in the order determined by their natural order or the given Icomparer implementation .

How to use stream.sorted() method in Java

In Java 8 and later, you can use the Stream API to sort a list. It provides the sorted method , which can be used to sort the elements of a stream. Here's an example of how to sort a list of integers using a 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]

    }
}

As you can see, the list of numbers is converted into a stream using the stream() method . The sorted() method is then called to sort the elements in the stream . The collect(Collectors.toList()) method is used to collect the sorted elements back into a list. The result is a new list containing the sorted elements. The output is [1, 2, 3, 4, 5] . stream.sorted() is best used when you have a stream of elements that need to be sorted. For example, if you have a stream of integers and you want to sort them in ascending order, then it is better to use the stream.Sorted() method for this .

Conclusion

In this tutorial, you learned that there are several ways to sort a list in Java - the Collections.sort() method , the stream.sorted() method , and the List.sort() method . Which of these methods is best to use depends on the specific requirements of the task at hand. I hope this article has given you the correct information on how to sort a list in Java. Happy coding!