mapToInt() in Java

In Java, the Stream API is responsible for storing the mapToInt() method which was introduced in the Java 8 version. The main purpose of mapToInt() method is used for the transformation of the elements from a stream into an IntStream.

Let's understand about mapToInt() method in detail in the following paragraphs.

Java mapToInt() of Stream API

In Java, the mapToInt() method is majorly utilized when the user is dealing with values that are primitive int rather than regular objects. In other words, the mapToInt() method is primarily used for applying a mapping function on every individual element present in the stream, and converts them into an int value.

The mapToInt() method consists of two method signatures that will be discussed later in the paragraphs. The user is responsible for specifying the mapping function and this must be of the ToIntFunction< super T > type. In the previously mentioned syntax, T is used for representing the type of elements which are available in the original stream. The result generated by the mapToInt() method will be an IntStream which stores an int values.

One of the major advantages of using the mapToInt() method in Java is that it provides potential related to performance improvement. Users can lead to highly efficient memory usage while working with primitive data types. Also, it provides higher performance when compared to dealing with objects of streams. When the user deals with large datasets or performance-based applicatoins, then the usage of mapToInt() method could be particularly beneficial.

For instance, during operations related to mathematics or statics the usage of mapToInt() could be proved highly efficient and useful. Additionally, various types of methods are provided by Java for the resulting IntStream which can be utilized for tailoring and operating with int values. Few methods or operations provided are sum, max, min, average, etc.

Let's understand about the mapToInt() method in detail with the help of a Java example program.

Filename: MapToIntExample.java

// Java program to demonstrate the features and functionalities of mapToInt() method in Java. 
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
class CollegeStudent {
    private String student_name;
    private int student_age;
    private List<String> student_subjects;
    public CollegeStudent(String student_name, int student_age, String... student_subjects) {
        this.student_name = student_name;
        this.student_age = student_age;
        this.student_subjects = Arrays.asList(student_subjects);
    }
    public String get_Name() {
        return student_name;
    }
    public int get_Age() {
        return student_age;
    }
    public List<String> get_Subjects() {
        return student_subjects;
    }
    @Override
    public String toString() {
        return "CollegeStudent{" +
                "student_name='" + student_name + '\'' +
                ", student_age=" + student_age +
                ", student_subjects=" + student_subjects +
                '}';
    }
}
public class MapToIntExample {
    public static void main(String[] args) {
        // Creation of a list of CollegeStudent objects
        List<CollegeStudent> students = Arrays.asList(
                new CollegeStudent("Eshwar", 20, "Math", "Physics"),
                new CollegeStudent("Sreeram", 22, "Computer Science", "Java"),
                new CollegeStudent("Arti", 21, "English", "History"),
                new CollegeStudent("Meghana", 23, "Chemistry", "Biology"));
        // Using mapToInt to extract and process ages of students
        IntStream ageStream = students.stream().mapToInt(CollegeStudent::get_Age);
        // Displaying original list of students
        System.out.println("Original List of Students: ");
        students.forEach(System.out::println);
        // Displaying ages of students using mapToInt
        System.out.println("\nAges of Students using mapToInt: ");
        ageStream.forEach(student_age -> System.out.print(student_age + " "));
        // Using mapToInt to calculate total number of characters in all subject names
        IntStream subjectNameLengthStream = students.stream()
                .flatMap(student -> student.get_Subjects().stream()) // Flattening student_subjects
                .mapToInt(String::length); // Mapping to length of each subject student_name
        // Displaying lengths of subject names
        System.out.println("\n\nLengths of Subject Names using mapToInt: ");
        subjectNameLengthStream.forEach(length -> System.out.print(length + " "));
        // Using mapToInt and filter to get the sum of ages of students studying Java
        int sumAgesJavaStudents = students.stream()
                .filter(student -> student.get_Subjects().contains("Java")) // Filtering Java students
                .mapToInt(CollegeStudent::get_Age) // Mapping to ages
                .sum(); // Calculating sum
        System.out.println("\n\nSum of Ages of Students studying Java: " + sumAgesJavaStudents);
        // Using mapToInt and collecting to create a list of ages
        List<Integer> ageList = students.stream()
                .mapToInt(CollegeStudent::get_Age) // Mapping to ages
                .boxed() // Convert IntStream to Stream<Integer>
                .collect(Collectors.toList()); // Collecting to list
        System.out.println("\nList of Ages collected using mapToInt and collect: " + ageList);
    }
}

Output:

Original List of Students:
CollegeStudent{student_name='Eshwar', student_age=20, student_subjects=[Math, Physics]}
CollegeStudent{student_name='Sreeram', student_age=22, student_subjects=[Computer Science, Java]}
CollegeStudent{student_name='Arti', student_age=21, student_subjects=[English, History]}
CollegeStudent{student_name='Meghana', student_age=23, student_subjects=[Chemistry, Biology]}

Ages of Students using mapToInt:
20 22 21 23

Example 2:

Filename: MapToIntExample1.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
class OfficeEmployee {
    private String EmployeeName;
    private int EmployeeSalary;
    public OfficeEmployee(String EmployeeName, int EmployeeSalary) {
        this.EmployeeName = EmployeeName;
        this.EmployeeSalary = EmployeeSalary;
    }
    public String Get_Name() {
        return EmployeeName;
    }
    public int Get_Salary() {
        return EmployeeSalary;
    }
    @Override
    public String toString() {
        return "OfficeEmployee{" +
                "EmployeeName='" + EmployeeName + '\'' +
                ", EmployeeSalary=" + EmployeeSalary +
                '}';
    }
}
public class MapToIntExample1{
    public static void main(String[] args) {
        // Creation of a list of OfficeEmployee objects
        List<OfficeEmployee> employees = Arrays.asList(
                new OfficeEmployee("Eshwar", 50000),
                new OfficeEmployee("Sreeram", 60000),
                new OfficeEmployee("Arti", 75000),
                new OfficeEmployee("Meghana", 90000)
        );
        // Using mapToInt to calculate bonus based on EmployeeSalary
        IntStream bonusStream = employees.stream()
                .mapToInt(employee -> calculateBonus(employee.Get_Salary()));
        // Displaying original list of employees
        System.out.println("Original List of Employees: ");
        employees.forEach(System.out::println);
        // Displaying bonus amounts using mapToInt
        System.out.println("\nBonus Amounts using mapToInt: ");
        bonusStream.forEach(bonus -> System.out.print(bonus + " "));
        // Using mapToInt to categorize employees into EmployeeSalary ranges
        IntStream salaryRangeStream = employees.stream()
                .mapToInt(employee -> categorizeSalaryRange(employee.Get_Salary()));
        // Displaying EmployeeSalary ranges
        System.out.println("\n\nSalary Ranges using mapToInt: ");
        salaryRangeStream.forEach(range -> System.out.print(range + " "));
        // Using mapToInt and filter to get total EmployeeSalary of high-performing employees
        int totalHighPerformersSalary = employees.stream()
                .filter(employee -> calculatePerformanceRating(employee.Get_Salary()) > 0.8)
                .mapToInt(OfficeEmployee::Get_Salary)
                .sum();
        System.out.println("\n\nTotal Salary of High Performers: " + totalHighPerformersSalary);
        // Using mapToInt and collecting to create a list of incremented salaries
        List<Integer> incrementedSalaries = employees.stream()
                .mapToInt(employee -> employee.Get_Salary() + 10000)
                .boxed()
                .collect(Collectors.toList());
        System.out.println("\nList of Incremented Salaries using mapToInt and collect: " + incrementedSalaries);
    }
    private static int calculateBonus(int EmployeeSalary) {
        // Simulated bonus calculation based on EmployeeSalary
        return (int) (EmployeeSalary * 0.1);
    }
    private static int categorizeSalaryRange(int EmployeeSalary) {
        // Simulated EmployeeSalary range categorization
        if (EmployeeSalary < 60000) return 1;
        else if (EmployeeSalary < 80000) return 2;
        else return 3;
    }
    private static double calculatePerformanceRating(int EmployeeSalary) {
        // Simulated performance rating calculation based on EmployeeSalary
        return EmployeeSalary > 70000 ? 0.9 : 0.7;
    }
}

Output:

Original List of Employees:
OfficeEmployee{EmployeeName=Eshwar, EmployeeSalary=50000}
OfficeEmployee{EmployeeName='Sreeram', EmployeeSalary=60000}
OfficeEmployee{EmployeeName='Arti', EmployeeSalary=75000}
OfficeEmployee{EmployeeName='Meghana', EmployeeSalary=90000}

Bonus Amounts using mapToInt:
5000 6000 7500 9000

Salary Ranges using mapToInt:
1 2 2 3

Next TopicMethods of Gson in Java

← prev next →