Stream count() Function in Java

In Java, the count() function was introduced in Java 8 as a part of Java Stream API. It is used to count the number of elements in a Stream. It is terminal operation. The count() method may traverse the stream's items to provide a result or a side effect because it is a terminal operation. The stream pipeline is deemed spent after executing count(), and we are not allowed to utilize the stream again. In this section, we will discuss the uses of count() function with example and Java program.

Syntax

The method returns the number of elements in the stream.

Uses of count() Function

1. Counting Elements:

It is helpful when you just need to know how many elements there are in a stream overall.

2. Counting Distinct Elements:

We can use the count() function to count the number of distinct elements in a stream by combining distinguish() and count().

CountExample.java

import java.util.*;
public class CountExample {
    public static void main(String[] args) { 
        List<Integer> lt = Arrays.asList(10, 23, 14, 46, 28, 150, 112); 
        long total = lt.stream().count(); 
        System.out.println("Total number of elements in the list are: " + total); 
    } 
}

Output:

Total number of elements: 7

CountDistinct.java

import java.util.*;
class CountDistinct {
    public static void main(String[] args) {    
        List<String> lt = Arrays.asList("Hi", "Hi", "Where", "Java", "Java", "Program");  
        long distinct = lt.stream().distinct().count(); 
        // Printing the total  number of distinct elements 
        System.out.println("Total number of distinct elements: " + distinct); 
    } 
}

Output:

Total number of distinct elements: 4

Explanation

The stream() method is used to create a stream from a list of strings. Use the distinct() function to maintain distinct components in the stream. The result is then sent to the terminal using the count() method, which counts the unique elements.

CountObjects.java

import java.util.ArrayList;
import java.util.List;
class Student {
    private String firstName;
    private String lastName;
    private int grade;
    public Student(String firstName, String lastName, int grade) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.grade = grade;
    }
}
class CountObjects {
    public static void main(String[] args) {
        // Obtain a list of students
        List<Student> students = getStudents();
        // Calculate the total count of students using Java Streams
        long totalStudentCount = students.stream().count();
        // Display the total count of students
        System.out.println("Total count of students: " + totalStudentCount);
    }
    // Method to retrieve a list of sample students
    private static List<Student> getStudents() {
    List<Student> stl = new ArrayList<>();
    stl.add(new Student("Ravi", "Kumar", 6));
    stl.add(new Student("Priya", "Sharma", 5));
    stl.add(new Student("Amit", "Patel", 7));
    stl.add(new Student("Ananya", "Desai", 4));
    stl.add(new Student("Vikram", "Reddy", 9));
    return studentList;
}
}

Output:

Total count of students: 5

Explanation

First name, last name, and grade are the attributes that describe a Student class in the code. The Main class illustrates the fundamental use of Java Streams and class structures by computing and printing the total count of sample students obtained via the retrieveStudents() function. It is done by using Java Streams.

Advantages of count() Function

1. Parallel Processing

The count() operation can take advantage of parallel processing for large datasets, potentially improving performance. Parallel streams can be created using parallelStream().

2. Conditional Counting

Using the filter() operation in conjunction with count(), we can perform conditional counting based on specific criteria.

3. Performance Implications

While count() is generally efficient, it is crucial to be mindful of its usage with infinite streams. In such cases, the operation might never terminate.

4. Combining Multiple Count Operations

We can use the Collectors.counting() collector to obtain the count result as a Long type.

5. Counting with Grouping:

When working with grouped data, the counting() collector is useful for counting elements in each group.

Map<String, Long> countByCategory = list.stream() .collect(Collectors.groupingBy(Student::getCategory, Collectors.counting()));

Conclusion

In summary, Java's count() function is a vital tool for stream-based processing. Count() is a useful tool in many situations due to its efficiency and flexibility, which may be applied to counting simple items, different elements, or bespoke objects. Developers may fully utilize the Stream API for data analysis and modification by being aware of its syntax and use cases.

Next TopicString.strip() Method in Java

← prev next →