Java Float compare() Method

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The Float.compare() method in Java is used to compare two specified float values. This method is a static method in the Float class, and it is useful for sorting and comparing float values.

Table of Contents

1. Introduction
2. compare() Method Syntax
3. Examples
   • Comparing Positive Float Values
   • Comparing Negative Float Values
   • Handling Special Values (Infinity and NaN)
4. Real-World Use Case
5. Conclusion

Introduction

The Float.compare() method compares two specified float values and returns an integer indicating their relative order. This method is particularly useful for sorting and comparing float values in collections.

compare() Method Syntax

The syntax for the Float.compare() method is as follows:

public static int compare(float f1, float f2)

• f1: The first float value to be compared.
• f2: The second float value to be compared.

The method returns:

• 0 if f1 is numerically equal to f2.
• A value less than 0 if f1 is numerically less than f2.
• A value greater than 0 if f1 is numerically greater than f2.

Examples

Comparing Positive Float Values

The compare() method can be used to compare two positive float values.

Example

public class CompareFloatExample {
    public static void main(String[] args) {
        float f1 = 5.67f;
        float f2 = 8.34f;

        int result = Float.compare(f1, f2);

        if (result < 0) {
            System.out.println(f1 + " is less than " + f2);
        } else if (result > 0) {
            System.out.println(f1 + " is greater than " + f2);
        } else {
            System.out.println(f1 + " is equal to " + f2);
        }
    }
}

Output:

5.67 is less than 8.34

In this example, the method compares the values 5.67f and 8.34f, resulting in 5.67f being less than 8.34f.

Comparing Negative Float Values

The compare() method can also be used to compare negative float values.

Example

public class CompareNegativeFloatExample {
    public static void main(String[] args) {
        float f1 = -5.67f;
        float f2 = -8.34f;

        int result = Float.compare(f1, f2);

        if (result < 0) {
            System.out.println(f1 + " is less than " + f2);
        } else if (result > 0) {
            System.out.println(f1 + " is greater than " + f2);
        } else {
            System.out.println(f1 + " is equal to " + f2);
        }
    }
}

Output:

-5.67 is greater than -8.34

In this example, the method compares the values -5.67f and -8.34f, resulting in -5.67f being greater than -8.34f.

Handling Special Values (Infinity and NaN)

The compare() method correctly handles special values like positive infinity, negative infinity, and NaN (Not-a-Number).

Example

public class SpecialValuesExample {
    public static void main(String[] args) {
        float posInf = Float.POSITIVE_INFINITY;
        float negInf = Float.NEGATIVE_INFINITY;
        float nan = Float.NaN;

        System.out.println("Comparing POSITIVE_INFINITY and 1.0: " + Float.compare(posInf, 1.0f));
        System.out.println("Comparing NEGATIVE_INFINITY and 1.0: " + Float.compare(negInf, 1.0f));
        System.out.println("Comparing NaN and 1.0: " + Float.compare(nan, 1.0f));
    }
}

Output:

Comparing POSITIVE_INFINITY and 1.0: 1
Comparing NEGATIVE_INFINITY and 1.0: -1
Comparing NaN and 1.0: 1

In this example, the method correctly handles and compares the special values POSITIVE_INFINITY, NEGATIVE_INFINITY, and NaN.

Real-World Use Case

Sorting Float Values in a Collection

In a real-world application, you might need to sort a collection of float values. The Float.compare() method can be used to facilitate this sorting.

Example

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

public class SortFloatValuesExample {
    public static void main(String[] args) {
        List<Float> floatList = new ArrayList<>();
        floatList.add(5.67f);
        floatList.add(8.34f);
        floatList.add(3.21f);
        floatList.add(1.23f);

        Collections.sort(floatList, Float::compare);

        System.out.println("Sorted float values: " + floatList);
    }
}

Output:

Sorted float values: [1.23, 3.21, 5.67, 8.34]

In this example, the Float.compare() method is used to sort a list of float values in ascending order.

Conclusion

The Float.compare() method in Java is a powerful and useful tool for comparing float values. By understanding how to use this method, you can efficiently handle tasks that involve comparing and sorting float values in your Java applications. Whether you are dealing with positive or negative values, handling special cases, or sorting collections, the compare() method provides a reliable solution for these tasks.